Wikibooks plwikibooks https://pl.wikibooks.org/wiki/Wikibooks:Strona_g%C5%82%C3%B3wna MediaWiki 1.46.0-wmf.26 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 828 45669 541317 538575 2026-04-29T16:53:08Z Persino 2851 541317 Scribunto text/plain local p={}; p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga) local liczba_elementow_ponumerowanych_w_tablicy=0; local czy_puste_wliczac=p.CzyTak(wliczac); local czy_mnoga=p.CzyTak(mnoga); for _1,_2 in ipairs(tabela)do if((not czy_puste_wliczac)or((czy_puste_wliczac)and(p.CzyTak(_2))))then liczba_elementow_ponumerowanych_w_tablicy=liczba_elementow_ponumerowanych_w_tablicy+1; if((czy_mnoga)and(liczba_elementow_ponumerowanych_w_tablicy>1))then return liczba_elementow_ponumerowanych_w_tablicy;end; end; end; return liczba_elementow_ponumerowanych_w_tablicy; end; p["LiczbaElementówNumerowanychSzablonu"]=function(frame) local parametry_modul=require("Module:Parametry"); return parametry_modul["LiczbaElementówNumerowanychTablicy"](frame:getParent().args,frame.args["niepuste"],frame.args["mnoga"]); end; p["LiczbaElementówNienazwanychTablicy"] = function(tabela,wliczac,mnoga) local czy_puste_wliczac=p.CzyTak(wliczac); local czy_mnoga=p.CzyTak(mnoga); local liczba_elementow_nienazwanych_w_tablicy=0; for _1,_2 in pairs(tabela)do if(type(_1)=="number")then if((not czy_puste_wliczac)or((czy_puste_wliczac)and(p.CzyTak(_2))))then liczba_elementow_nienazwanych_w_tablicy=liczba_elementow_nienazwanych_w_tablicy+1; if((czy_mnoga)and(liczba_elementow_nienazwanych_w_tablicy>1))then return liczba_elementow_nienazwanych_w_tablicy;end; end; end; end; return liczba_elementow_nienazwanych_w_tablicy; end; p["LiczbaParametrówNienazwanychSzablonu"] = function (frame) return p["LiczbaElementówNienazwanychTablicy"](frame:getParent().args,frame.args["niepuste"],frame.args["mnoga"]) end; p["LiczbaElementówTablicy"]=function(tabela,wliczac) local czy_puste_wliczac=p.CzyTak(wliczac); local liczba_elementow_w_tablicy=0; for _1,_2 in pairs(tabela)do if((not czy_puste_wliczac)or((czy_puste_wliczac)and(p.CzyTak(_2))))then liczba_elementow_w_tablicy=liczba_elementow_w_tablicy+1; end; end; return liczba_elementow_w_tablicy; end; p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe) local czy_puste_wliczac=p.CzyTak(wliczac); local liczba_elementow_w_tablicy=0; local techniczne_modul=require("Module:Techniczne"); local wzor="^"..techniczne_modul["PrzekształćWzórDoCzystegoTekstu"](przedrostek).."(%d+)$"; for _1,_2 in pairs(tabela)do local string_liczba=tonumber(_1) or nil; local czy_liczba=((string_liczba)and(czy_formy_numerkowe or p.TypeNumber(_1))and(string_liczba>0)); local zmienna=czy_liczba and przedrostek.._1 or nil; local element=(czy_liczba and tabela[zmienna] or nil) or (czy_liczba and tabela[_1] or (mw.ustring.match(tostring(_1),wzor) and tabela[_1] or nil) ); if(element)then if((not czy_puste_wliczac)or((czy_puste_wliczac)and(element~="")))then liczba_elementow_w_tablicy=liczba_elementow_w_tablicy+1; end; end; end; return liczba_elementow_w_tablicy; end; function p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame) return p.MaksymalnaLiczbaParametruNienazwanegoTablicy(frame:getParent().args,frame.args["niepuste"]); end; function p.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela, wliczac) local czy_puste_wliczac=p.CzyTak(wliczac); local liczba_elementow_ponumerowanych_w_tablicy=0; for _1,_2 in pairs(tabela)do if(type(_1)=="number")then if((not czy_puste_wliczac)or((czy_puste_wliczac)and(p.CzyTak(_2))))then liczba_elementow_ponumerowanych_w_tablicy=math.max(liczba_elementow_ponumerowanych_w_tablicy,_1); end; end; end; return (liczba_elementow_ponumerowanych_w_tablicy)and liczba_elementow_ponumerowanych_w_tablicy or 0; end; function p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame) return p.MinimalnaLiczbaParametruNienazwanegoTablicy(frame:getParent().args,frame.args["niepuste"]); end; function p.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,wliczac) local czy_puste_wliczac=p.CzyTak(wliczac); local liczba_elementow_ponumerowanych_w_tablicy; for _1,_2 in pairs(tabela)do if(type(_1)=="number")then if((not czy_puste_wliczac)or((czy_puste_wliczac)and(p.CzyTak(_2))))then if(not liczba_elementow_ponumerowanych_w_tablicy)then liczba_elementow_ponumerowanych_w_tablicy=_1; else liczba_elementow_ponumerowanych_w_tablicy=math.min(liczba_elementow_ponumerowanych_w_tablicy,_1); end; end; end; end; return (liczba_elementow_ponumerowanych_w_tablicy)and liczba_elementow_ponumerowanych_w_tablicy or 1; end; function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona) local liczba_maksimum=0; local liczba_minimum; for nazwa_parametru,wartosc_parametru in pairs(tabela)do local liczba_z_parametru=mw.ustring.match(nazwa_parametru,"^"..nazwa_parametru_okreslona.."%s(%d+)$") if(liczba_z_parametru)then local liczba=tonumber(liczba_z_parametru) or 0; liczba_maksimum=math.max(liczba_maksimum,liczba); if(not liczba_minimum)then liczba_minimum=(liczba>0)and liczba or 1; else liczba_minimum=math.min(liczba_minimum,(liczba>0)and liczba or 1); end; elseif(nazwa_parametru_okreslona==nazwa_parametru)then liczba_maksimum=math.max(liczba_maksimum,1); if(not liczba_minimum)then liczba_minimum=1; else liczba_minimum=math.min(liczba_minimum,1); end; end; end; if(not liczba_minimum)then liczba_minimum=1;end; return liczba_minimum,liczba_maksimum; end; p["CzySąParametryNumerowaneSzablonu"] = function(frame) local czy_sa_elementy_tablicy=require("Module:Parametry")["CzySąElementyNumerowaneTablicy"](frame:getParent().args,frame.args["niepuste"]); if(czy_sa_elementy_tablicy)then return "tak";end; return; end; p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac) local czy_puste_wliczac=p.CzyTak(wliczac); for _1,_2 in ipairs(tabela)do if((not czy_puste_wliczac)or((czy_puste_wliczac)and(p.CzyTak(_2))))then return true; end; end; return false; end; p["CzySąParametryNienazwaneSzablonu"] = function(frame) local czy_sa_elementy_tablicy=require("Module:Parametry")["CzySąElementyNienazwaneTablicy"](frame:getParent().args,frame.args["niepuste"]); if(czy_sa_elementy_tablicy)then return "tak";end; return; end; p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac) local czy_puste_wliczac=p.CzyTak(wliczac); for _1,_2 in pairs(tabela)do if(type(_1)=="number")then if((not czy_puste_wliczac)or((czy_puste_wliczac)and(p.CzyTak(_2))))then return true; end; end; end; return false; end; p["CzySąParametryNazwaneSzablonu"] = function(frame) local czy_sa_elementy_tablicy=require("Module:Parametry")["CzySąElementyNazwaneTablicy"](frame:getParent().args,frame.args["niepuste"]); if(czy_sa_elementy_tablicy)then return "tak";end; return; end; p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac) local czy_puste_wliczac=p.CzyTak(wliczac); for _1,_2 in pairs(tabela)do if(type(_1)~="number")then if((not czy_puste_wliczac)or((czy_puste_wliczac)and(p.CzyTak(_2))))then return true; end; end; end; return false; end; p["CzySąParametrySzablonu"] = function(frame) local czy_sa_elementy_tablicy=require("Module:Parametry")["CzySąElementyTablicy"](frame:getParent().args,frame.args["niepuste"]); if(czy_sa_elementy_tablicy)then return "tak";end; return; end; p["CzySąElementyTablicy"]=function(tabela,wliczac) local czy_puste_wliczac=p.CzyTak(wliczac); for _1,_2 in pairs(tabela)do if((not czy_puste_wliczac)or((czy_puste_wliczac)and(p.CzyTak(_2))))then return true; end; end; return false; end; p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame) local parametry_modul=require("Module:Parametry"); local czy_jest_taki_element=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](frame:getParent().args,frame.args["niepuste"]); if(czy_jest_taki_element)then return "tak";end; end; p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac) local czy_puste_wliczac=p.CzyTak(wliczac); local i=1; local czy=false; for _1,_2 in pairs(args)do if(type(_1)=="number")then if((not czy_puste_wliczac)or((czy_puste_wliczac)and(p.CzyTak(_2))))then if(_1==1)then czy=true;end; if(i>1)then return false; else i=i+1; end; end; end; end; if((czy)or(i==1))then return true;end; return false; end; p["KopiujTabelęŁańcuchów"]=function(args) local args2={}; local wzor_temp=args["wzór"];local wzor_wszystko=args["wzór wszystko"]; local podstawienie_temp=args.podstawienie;local podstawienie_wszystko=args["podstawienie wszystko"]; local wzor2_temp=args["wzór 2"];local wzor_wszystko_2=args["wzór wszystko 2"]; local przedrostek_temp=args.przedrostek;local przedrostek_wszystko=args["przedrostek wszystko"]; local przyrostek_temp=args.przyrostek;local przyrostek_wszystko=args["przyrostek wszystko"]; for name,value in pairs(args.tabela)do local wzor=wzor_temp and wzor_temp[name] or wzor_wszystko; local podstawienie=wzor and (podstawienie_temp and podstawienie_temp[name] or podstawienie_wszystko) or nil; if(wzor and podstawienie)then value=mw.ustring.gsub(value,wzor,podstawienie);end; local wzor2=wzor2_temp and wzor2_temp[name] or wzor_wszystko_2; if(wzor2)then value=mw.ustring.match(value,wzor2);end; if(value)then local przedrostek=przedrostek_temp and przedrostek_temp[name] or przedrostek_wszystko; local przyrostek=przyrostek_temp and przyrostek_temp[name] or przyrostek_wszystko; args2[name]=(przedrostek or '')..value..(przyrostek or ''); end; end; return args2; end; p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2) local czy_puste_wliczac_1=p.CzyTak(wliczac_1); local czy_puste_wliczac_2=p.CzyTak(wliczac_2); local tabelka2={}; for name,value in pairs(tabelka)do if(((not czy_puste_wliczac_1)or((czy_puste_wliczac_1)and(p.CzyTak(name))))and((not czy_puste_wliczac_2)or((czy_puste_wliczac_2)and(p.CzyTak(value)))))then tabelka2[name]=value; end; end; return tabelka2; end; p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2) local czy_puste_wliczac_1=p.CzyTak(wliczac_1); local czy_puste_wliczac_2=p.CzyTak(wliczac_2); local tabelka3={}; for name,value in pairs(tabelka)do if(((not czy_puste_wliczac_1)or((czy_puste_wliczac_1)and(p.CzyTak(name))))and((not czy_puste_wliczac_2)or((czy_puste_wliczac_2)and(p.CzyTak(value)))))then local czy=p.CzyJestTakiKluczTabeli(tabelka2,name); if(not czy)then tabelka3[name]=value; end; end; end; return tabelka3; end; p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2) local czy_puste_wliczac_1=p.CzyTak(wliczac_1); local czy_puste_wliczac_2=p.CzyTak(wliczac_2); local szablonowe_potrzebne_modul=require("Module:Szablonowe/Potrzebne"); local kopiuj_metatable=function(value,funkcja,funkcja2) local __metatabelka=getmetatable(value); if((__metatabelka)and(__metatabelka.tablica))then --Dla [[Module:Szablonowe/Potrzebne]] local tabelka_metatable=__metatabelka.tablica(); local __metatabelka2={}; szablonowe_potrzebne_modul.MetaTabelkaSzablonowe(__metatabelka2); local value2={}; setmetatable(value2,__metatabelka2); local tabelka_metatable2=__metatabelka2.tablica(); funkcja2(tabelka_metatable,tabelka_metatable2); funkcja(value2,false); else funkcja(value,true); end; end; local function kopiuj(tabelka,tabelka_nowa) local tabelka2=tabelka_nowa or {}; for name,value in pairs(tabelka)do if(((not czy_puste_wliczac_1)or((czy_puste_wliczac_1)and(p.CzyTak(name))))and((not czy_puste_wliczac_2)or((czy_puste_wliczac_2)and(p.CzyTak(value)))))then if(type(value)=="table")then kopiuj_metatable(value,function(value,jak) if(jak)then tabelka2[name]=kopiuj(value); else tabelka2[name]=value; end; end,kopiuj); else tabelka2[name]=value; end; end; end; return tabelka2; end; local tabela_kopiuj={}; kopiuj_metatable(tabelka,function(value,jak) if(jak)then tabela_kopiuj=kopiuj(value); else tabela_kopiuj=value; end; end,kopiuj); return tabela_kopiuj; end; p["NazwanyLiczbą"] = function(frame) local pf=frame:getParent() local numer_parametru=frame.args[1] if(numer_parametru)then numer_parametru=tonumber(numer_parametru); if(numer_parametru and pf.args[numer_parametru])then return "tak" end end; return; end p["NazwanyCiągiem"] = function (frame) local pf=frame:getParent() local klucz_parametru=frame.args[1] if(klucz_parametru)then local klucz_parametru_do_liczby=tonumber(klucz_parametru); if((not klucz_parametru_do_liczby)and(pf.args[klucz_parametru]))then return "tak" end end; return; end; function p.Nazwane(frame) local pf = frame:getParent() for _, nazwa_parametru in ipairs(frame.args)do local wartosc_parametru_nazwanego=pf.args[mw.text.trim(nazwa_parametru)] if(wartosc_parametru_nazwanego)then return "tak" end end return; end function p.Nienazwane(frame) local pf = frame:getParent() for _, wartosc_parametru in ipairs(frame.args)do wartosc_parametru=mw.text.trim(wartosc_parametru) for name, wartosc_parametru2 in pairs(pf.args) do if(type(name)=="number")then if(mw.text.trim(wartosc_parametru2)==wartosc_parametru)then return "tak" end end; end end return; end function p.Numerowane(frame) local pf = frame:getParent() for _, wartosc_parametru in ipairs(frame.args)do wartosc_parametru=mw.text.trim(wartosc_parametru) for _, wartosc_parametru2 in ipairs(pf.args) do if(mw.text.trim(wartosc_parametru2)==wartosc_parametru)then return "tak" end end end return; end p["Odstępy"] = function(frame) local PobierzParametr=p.PobierzParametr(frame); local nazwa=PobierzParametr(1) or PobierzParametr("nazwa"); local czy=PobierzParametr(2) or PobierzParametr("wewnątrz"); local dolny_myslnik=PobierzParametr(3) or PobierzParametr("dolny-myślnik"); local odstep_spacje=PobierzParametr(4) or PobierzParametr("spacje"); if(not p.CzyTak(nazwa))then return nazwa;end; local m_=(p.CzyTak(odstep_spacje) and "" or "_"); nazwa=mw.ustring.gsub(nazwa,"^[%s"..m_.."]+",""); nazwa=mw.ustring.gsub(nazwa,"[%s"..m_.."]+$","") if(p.CzyTak(czy))then nazwa=mw.ustring.gsub(nazwa,"[%s"..m_.."]+",(p.CzyTak(dolny_myslnik) and "_" or " ")); end; return nazwa; end; function p.DodajElementDoZbioru(tabela,wartosc) if(wartosc==nil)then return; end; if(type(tabela)~="table")then return;end; for _,element_tabeli in pairs(tabela)do if(element_tabeli==wartosc)then return false; end; end; table.insert(tabela,wartosc); return true; end; function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc) if(wartosc==nil)then return;end; if(type(tabela)~="table")then return;end; for _, element_tabeli in ipairs(tabela)do if(element_tabeli==wartosc)then return true; end; end; return false; end; function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc) if(wartosc==nil)then return;end; if(type(tabela)~="table")then return;end; for name,value in pairs(tabela)do if(type(name)=="number")then if(value==wartosc)then return true; end; end; end; return false; end; function p.CzyJestTakiKluczTabeli(tabela,klucz) if(klucz==nil)then return;end; if(type(tabela)~="table")then return;end; local wartosc=tabela[klucz]; if(wartosc~=nil)then return true;end; return false; end; function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc) if((klucz==nil)or(wartosc==nil))then return;end; if(type(tabela)~="table")then return;end; for __klucz, __wartosc in pairs(tabela)do if((__klucz==klucz)and(__wartosc==wartosc))then return true; end; end; return false; end; p["ŁączDwieTabele"] = function (tabelka1,tabelka2) local parametry_modul=require("Module:Parametry"); return (tabelka2 and parametry_modul["CzySąElementyTablicy"](tabelka2)) and ((tabelka1 and parametry_modul["CzySąElementyTablicy"](tabelka1)) and parametry_modul["ŁączNumerowaneTabele"]{[1]=tabelka1,[2]=tabelka2,} or tabelka2) or tabelka1; end; p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabelka1,tabelka2) local parametry_modul=require("Module:Parametry"); return (tabelka1 and parametry_modul["CzySąElementyNumerowaneTablicy"](tabelka1))and ((tabelka2 and parametry_modul["CzySąElementyNumerowaneTablicy"](tabelka2))and parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"]{[1]=tabelka1,[2]=tabelka2} or tabelka1) or tabelka2; end; p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabelka1,tabelka2) local parametry_modul=require("Module:Parametry"); return (tabelka1 and parametry_modul["CzySąElementyNienazwaneTablicy"](tabelka1))and ((tabelka2 and parametry_modul["CzySąElementyNienazwaneTablicy"](tabelka2))and parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"]{[1]=tabelka1,[2]=tabelka2} or tabelka1) or tabelka2; end; p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabelka1,tabelka2) local parametry_modul=require("Module:Parametry"); return (tabelka1 and parametry_modul["CzySąElementyNazwaneTablicy"](tabelka1))and ((tabelka2 and parametry_modul["CzySąElementyNazwaneTablicy"](tabelka2))and parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"]{[1]=tabelka1,[2]=tabelka2} or tabelka1) or tabelka2; end; p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; p["ŁączTabele"] = function(args,args2) local tabela={}; local par1=(args2.CzyPairsTablic)and pairs or ipairs; local czy_number_nie_tylko_tablic=(not args2.CzyPairsTablic)and true or false; local par2=(args2["CzyPairsElementówTablic"])and pairs or ipairs; local czy_number_nie_tylko_elementow_tablic=(not args2["CzyPairsElementówTablic"])and true or false; local czy_nazwane=(args2.CzyNazwaneElementyTabel)and true or false; local czy_nie_tylko_nazwane=(not args2.CzyTylkoNazwaneElementyTabel)and true or false; local nazwij_elementy_numerowane=(args2.NazwijElementyNumerowane) and true or false; for licznik, args_tabeli in par1(args)do if(((czy_number_nie_tylko_tablic)or(type(licznik)=="number"))and(type(args_tabeli)=="table"))then for name,value in par2(args_tabeli)do if((czy_nie_tylko_nazwane)and((czy_number_nie_tylko_elementow_tablic)or(type(name)=="number")))then if(nazwij_elementy_numerowane)then if(not tabela[name])then tabela[name]=value;end; else table.insert(tabela,value); end; elseif((czy_nazwane)and(czy_nie_tylko_nazwane or ((not czy_nie_tylko_nazwane)and(type(name)~="number"))))then if(not tabela[name])then tabela[name]=value;end; end; end; end; end; return tabela; end; p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2) if(not tabelka_1)then return nil;end; if(not tabelka_2)then return tabelka_1;end; for name,_ in pairs(tabelka_1)do if(tabelka_2[name]~=nil)then tabelka_1[name]=nil; end; end; return tabelka_1; end; p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args) local tabela_poczatkowa=args[1]; local tabela={}; local lens=#args; for name,value in pairs(tabela_poczatkowa)do local yes=false; for i=2,lens,1 do if(args[i][name]~=nil)then yes=true; break; end; end; if(not yes)then tabela[name]=value; end; end; return tabela; end; function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; function p.TypeString(zmienna) return (type(zmienna)=="string"); end; function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; function p.TypeNil(zmienna) return (zmienna==nil); end; local function CzyTakSilnik(args,funkcja) local parametry_modul=require("Module:Parametry"); local parametr=p.CzyTak(args[2]) and require("Module:"..args[2])[args[1]] or args[1]; local argsfun; if(p.CzyTak(args[2]))then for name,value in pairs(args)do local typen=(type(name)=="number"); if(((typen)and((name~=1)and(name~=2)))or(not typen))then if(not argsfun)then argsfun={};end; argsfun[(typen and name>2) and (name-2) or name]=value; end; end; else parametr=tonumber(parametr) or parametr; if(type(parametr)=="string")then local parametr2=parametry_modul["Odstępy"](parametr); if(parametr2=="true")then parametr=true; elseif(parametr2=="false")then parametr=false; elseif(parametr2=="nil")then parametr=nil; else parametr=tonumber(parametr2) or parametr; end; end; end; return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; end; p["CzyTakCiąg"]=function(...) local frame_parametry={...}; local frame=(#frame_parametry>1)and frame_parametry or frame_parametry[1]; local czy_table=p.TypeTable(frame); if((czy_table and (not frame.getParent)) or (not czy_table))then local PobierzParametr=p.PobierzParametr(frame); local ciag=PobierzParametr("ciąg") or PobierzParametr(1); local parametry=PobierzParametr("parametry") or PobierzParametr(2); local parametry_modul=require("Module:Parametry"); return ciag and p.CzyTak{[1]=(p.TypeString(ciag) and parametry_modul["Odstępy"]{[1]=ciag,[2]="tak",} or ciag),[2]=parametry,} or false; else local args=p.PobierzArgsParametry(frame); return CzyTakSilnik(args,"CzyTakCiąg"); end; end; function p.CzyTak(...) local frame_parametry={...}; local frame=(#frame_parametry>1)and frame_parametry or frame_parametry[1]; local czy_table=p.TypeTable(frame); if((czy_table and (not frame.getParent)) or (not czy_table))then local PobierzParametr=p.PobierzParametr(frame); local zmienna;local parametry; if(czy_table)then local zmienna_temp=PobierzParametr("zmienna") or PobierzParametr(1); zmienna=zmienna_temp or frame; parametry=zmienna_temp and (PobierzParametr("parametry") or PobierzParametr(2)) or nil; else zmienna=frame; parametry=nil; end; if(zmienna~=nil)then if(p.TypeString(zmienna))then if(zmienna~="")then return "tak"; else return nil; end; elseif(p.TypeNumber(zmienna))then if(zmienna~=0)then return "tak"; else return nil; end; elseif(p.TypeBoolean(zmienna))then return (zmienna and "tak" or nil); elseif(p.TypeTable(zmienna))then local parametry_modul=require("Module:Parametry"); return (parametry_modul["CzySąElementyTablicy"](zmienna) and "tak" or nil); elseif(p.TypeFunction(zmienna))then return (zmienna(parametry) and "tak" or nil); else return nil; end; else return nil; end; else local args=p.PobierzArgsParametry(frame); return CzyTakSilnik(args,"CzyTak"); end; end; function p.PobierzFrameEwentualnieParent(frame) return (frame.getParent and (p.CzyTak(frame.args["wyspecjalizowana"]) and frame or frame:getParent()) or frame); end; function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica) local TempFunc=function(frame) local pf=p.PobierzFrameEwentualnieParent(frame); local args=pf.args; if(p.TypeTable(args))then return args; else return nil; end; end; if(not p.TypeNil(frame))then return p.TypeTable(frame) and (TempFunc(frame) or frame) or ((czy_nie_tablica_jako_tablica)and {frame,} or frame); else return {}; end; end; function p.PobierzParametryRamki(frame) local TempFun1=function(tablica) return function(nazwa) return tablica[nazwa]; end; end; local TempFun2=function(wartosc) local tak=true; return function(nazwa) if(tak)then tak=false; return wartosc; end; return nil; end; end; local tablica_parametrow_ramki=p.TypeTable(frame) and (p.TypeTable(frame.args) and TempFun1(frame.args) or TempFun1(frame)) or TempFun2(frame); return function(nazwa) return tablica_parametrow_ramki(nazwa); end; end; function p.PobierzElementNumerowanyZFrameLubTablicy(frame) local tablica_parametrow_funkcji=p.TypeTable(frame[1]) and p.TypeTable(frame[1].args)and frame[1].args or frame; return function(nazwa) local wartosc=tablica_parametrow_funkcji[nazwa]; return wartosc; end; end; function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) local __pobierz_parametr_table_args=nil; if(not p.TypeNil(frame))then if(p.TypeTable(frame))then local tak_frame_lub_parent=p.CzyTak(czy_frame_lub_parent); if((not tak_frame_lub_parent)or(not frame.getParent))then local __pobierz_parametr_table_args_temp=p.CzyTak(czy_frame) and frame.args or p.PobierzArgsParametry(frame); __pobierz_parametr_table_args=function(nazwa) return __pobierz_parametr_table_args_temp[nazwa or 1],1; end; elseif(tak_frame_lub_parent)then local pf=(frame.getParent)and frame:getParent() or nil; __pobierz_parametr_table_args=function(nazwa) local wartosc=frame.args[nazwa or 1] or (pf and pf.args[nazwa or 1] or nil); return wartosc,2; end; end; else local tak=true; __pobierz_parametr_table_args=function(nazwa) if(tak)then tak=false; return frame,0; end; return nil,0; end; end; else __pobierz_parametr_table_args=function(nazwa) return nil,0; end; end; return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; function p.And(frame) local czy="tak"; local parametry_modul=require("Module:Parametry"); local wartosc_uzyskana=nil; for _,wartosc in ipairs(frame.args)do czy=czy and parametry_modul["CzyTakCiąg"](wartosc); if(not czy)then return nil;end; wartosc_uzyskana=wartosc; end; return czy and wartosc_uzyskana or nil; end; function p.Or(frame) local czy=nil; for _,wartosc in ipairs(frame.args)do czy=czy or p["CzyTakCiąg"](wartosc); if(czy)then return wartosc;end; end; return nil; end; function p.Not(frame) local parametry_modul=require("Module:Parametry"); return (not parametry_modul["CzyTakCiąg"](frame.args[1]))and "tak" or nil; end; function p.Mniejszy(frame) local wyraz1=tonumber(frame.args[1]) or 0; local wyraz2=tonumber(frame.args[2]) or 0; if(wyraz1<wyraz2)then return "tak"; end; return; end; function p.IlePodano(frame) local args=frame.args; local args2=frame:getParent().args; local licznik=0; for _,name in pairs(args)do if(args2[name])then licznik=licznik+1; end; end; return licznik; end; p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter={}; function p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz) local html_modul=require("Module:Html"); klucz=html_modul.DecodeKoduHTMLZnaku(klucz); klucz=mw.ustring.gsub(klucz,"[%s_]+",""); klucz=mw.ustring.lower(klucz); return rawget(t,klucz); end; function p.IteratorPoNumerowanychElementachTablicy(t) local i=1; return function() local v=t[i]; if(v~=nil)then i=i+1;end; return v; end; end; p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu=function(tabela,funkcja) local keys={}; for name,_ in next,tabela do table.insert(keys,name); end; table.sort(keys,funkcja); return function(tablica,klucz) if(klucz==nil)then return keys[1];end; for k,_ in ipairs(keys)do if(keys[k]==klucz)then return keys[k+1]; end; end; end; end; function p.Max(...) local frame={...}; local PobierzElement=p.PobierzElementNumerowanyZFrameLubTablicy(frame); local parametr1=tonumber(PobierzElement(1)); local parametr2=tonumber(PobierzElement(2)); return math.max(parametr1,parametr2); end; function p.Min(...) local frame={...}; local PobierzElement=p.PobierzElementNumerowanyZFrameLubTablicy(frame); local parametr1=tonumber(PobierzElement(1)); local parametr2=tonumber(PobierzElement(2)); return math.min(parametr1,parametr2); end; return p; pjyigl7mkd3rvc1idbgbobm4af21v1g 10 48166 541369 535754 2026-04-30T11:21:23Z Persino 2851 /* Opis szablonu */ 541369 wikitext text/x-wiki {{Podstrona dokumentacji}} {{Lua|Linki}} {{Skomplikowany}} {{Szablony opakowań linków wewnętrznych}} {{#if:{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|{{Skrót szablonu|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}}}|{{DivLinia}}}} <!--DODAWAJ KATEGORIE NA DOLE STRONY --> == Opis szablonu == Jest to szablon linków inteligentnych (tzw. linki inteligentne), który koloruje linki w zależności do jakiej kategorii szablon zaliczy stronę wskazaną w nim. Zestaw możliwych kodów linkowych, znajduje się na stronie {{s|Link wewnętrzny}}, w miejscu pod tabelą nawigacyjną {{s|Tabela nawigacyjna}}, według jego wikikodu opisu, w postaci linku do szablonu arkusza stylów, lub w samej tabeli w parametrze z linkami przyjmujące kolory według ich odpowiednich wartości, a obok nich znajdują się znaczniki szablonowe z właściwymi wartościami ich. Szablon {{s|LinkOgólne}} i jego pochodne w ich definicji, obsługują nazwy przestrzenie nazw kanoniczne (angielskie) lub w jakimś języku, na danym projekcie siostrzanych lub w ich wersjach językowych. Wystarczy podać nazwę kanoniczną przestrzeni nazw, a ta nazwa zostanie przetłumaczona na nazwę charakterystyczną dla danego projektu, jeżeli podamy parametr: {{Parametr|analiza|tak}} (lub jego skrót: {{Parametr|a|tak}}), bez: {{Parametr|bez przetwarzania|tak}}, w przeciwnym przypadku tego nie zrobi. Na przykład na projekcie bieżącym dla szablonów ogólnie nie między-projektowych, wyświetlana nazwa przestrzeni nazw zostanie przetłumaczona na nazwę charakterystyczną dla polskiego {{NAZWASERWISU|po=a|wikipedia=tak|link=tak}}, jeżeli ustawimy szablon, by wyświetlał to w nazwie linku, to je robi możliwie po przetłumaczeniu na język polski, ona w adresie linku nie zostanie przetłumaczona, chyba że podamy parametr {{Parametr|analiza|tak}} (lub jego skrót: {{Parametr|a|tak}}) według powyższej specyfikacji. Szablon zwykle nie tłumaczy w adresie linku nazwy przestrzeni nazw, np. na język polski lub inny, podanym w definicji tego szablonu, jeżeli jest nazwą kanoniczną podaną w definicji tego szablonu, a jeżeli nie, to nie ma czego tłumaczyć (bo w definicji szablonu pod zmienną: {{Code|miano przestrzeni nazw}} (lub jego skrót: {{Parametr|m}}), np. jest podane: {{Code|Wikibooks}}, zamiast: {{Code|Project}}), chyba że w przeciwnym wypadku, chcemy, by przetłumaczył na język charakterystyczny dla danego projektu, wskazanym przez szablon, wtedy należy podać parametr poniżej opisany do szablonu do głębszej analizy linkowej. {{#if:{{Dopasuj|ciąg={{ROOTPAGENAME}}|wzór=2$}}|A nazwa przestrzeni nazw wyświetlana w nazwie linku za to zawsze zostanie przetłumaczona na nasz język.}} Szablon używa zmiennej: {{Code|miano przestrzeni nazw}} (lub jego skrót: {{Parametr|m}}), w sposób {{#switch:{{ROOTPAGENAME}}|LinkOgólne|LinkOgólne2=jawny (w postaci osobnego parametru) lub nie (w pierwszej zmiennej)|#default=niejawny (w postaci zmiennej w definicji tego szablonu, używając szablon {{s|LinkOgólne}})}}, w przeciwieństwie do {{s|Link wewnętrzny}}, który tego nie ma, tzn. nazwa przestrzeni nazw jest zawsze podana tam w sposób niejawny w postaci pierwszej zmiennej wraz z adresem linku na danym projekcie i kluczem projektu (wtedy nie ma osobnego parametru do interwiki) lub nie (w postaci zmiennej (zmiennych) do interwiki). == Skrót szablonu == Szablon {{s|{{ROOTPAGENAME}}}} posiada swój skrót: {{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}}}. == Użycie == {{LinkOgólne/linki|{{ROOTPAGENAME}}}} {{LinkOgólne/definicje|{{ROOTPAGENAME}}}} == Opis parametrów == {{#switch:{{ROOTPAGENAME}}|LinkWB= ; Pełne wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|z{{=}}|p{{=}}}}}} ; Pełne wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|za{{=}}|po{{=}}}}}} |LinkSpecjalna= ; Pełne pierwsze wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|2{{=}}|z{{=}}|p{{=}}|k{{=}}}}}} ; Pełne pierwsze wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|2{{=}}|za{{=}}|po{{=}}|klucz projektu{{=}}}}}} ; Pełne drugie wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|2{{=}}|z{{=}}|p{{=}}|kj{{=}}|kp{{=}}}}}} ; Pełne drugie wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|2{{=}}|za{{=}}|po{{=}}|kod języka{{=}}|kod projektu{{=}}}}}} |LinkSpecjalna2= ; Pełne pierwsze wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|z{{=}}|p{{=}}|k{{=}}}}}} ; Pełne pierwsze wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|za{{=}}|po{{=}}|klucz projektu{{=}}}}}} ; Pełne drugie wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|z{{=}}|p{{=}}|kj{{=}}|kp{{=}}}}}} ; Pełne drugie wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|za{{=}}|po{{=}}|kod języka{{=}}|kod projektu{{=}}}}}} |LinkOgólne= ; Pełne pierwsze wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|2{{=}}|z{{=}}|p{{=}}|k{{=}}|d{{=}}|m{{=}}|i{{=}}|w{{=}}}}}} ; Pełne pierwsze wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|2{{=}}|za{{=}}|po{{=}}|klucz projektu{{=}}|dyskusja{{=}}|miano przestrzeni nazw{{=}}|alias miana przestrzeni nazw{{=}}|wyświetl miano przestrzeni nazw{{=}}}}}} ; Pełne drugie wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|2{{=}}|z{{=}}|p{{=}}|kj{{=}}|kp{{=}}|d{{=}}|m{{=}}|i{{=}}|w{{=}}}}}} ; Pełne drugie wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|2{{=}}|za{{=}}|po{{=}}|kod języka{{=}}|kod projektu{{=}}|dyskusja{{=}}|miano przestrzeni nazw{{=}}|alias miana przestrzeni nazw{{=}}|wyświetl miano przestrzeni nazw{{=}}}}}} |LinkOgólne2= ; Pełne pierwsze wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|z{{=}}|p{{=}}|k{{=}}|d{{=}}|m{{=}}|i{{=}}}}}} ; Pełne pierwsze wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|za{{=}}|po{{=}}|klucz projektu{{=}}|dyskusja{{=}}|miano przestrzeni nazw{{=}}|alias miana przestrzeni nazw{{=}}}}}} ; Pełne drugie wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|z{{=}}|p{{=}}|kj{{=}}|kp{{=}}|d{{=}}|m{{=}}|i{{=}}}}}} ; Pełne drugie wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|za{{=}}|po{{=}}|kod języka{{=}}|kod projektu{{=}}|dyskusja{{=}}|miano przestrzeni nazw{{=}}|alias miana przestrzeni nazw{{=}}}}}} |#default={{#if:{{Dopasuj|ciąg={{ROOTPAGENAME}}|wzór=[^2]$}}|{{#if:{{#invoke:Parametry|Not|{{Dopasuj|ciąg={{ROOTPAGENAME}}|wzór=Specjalna2?$}}}}|{{#if:{{Dopasuj|ciąg={{ROOTPAGENAME}}|wzór=^Link%u%l+2?$}}| ; Pełne pierwsze wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|2{{=}}|z{{=}}|p{{=}}|k{{=}}|d{{=}}}}}} ; Pełne pierwsze wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|2{{=}}|za{{=}}|po{{=}}|klucz projektu{{=}}|dyskusja{{=}}}}}} ; Pełne drugie wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|2{{=}}|z{{=}}|p{{=}}|kj{{=}}|kp{{=}}|d{{=}}}}}} ; Pełne drugie wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|2{{=}}|za{{=}}|po{{=}}|kod języka{{=}}|kod projektu{{=}}|dyskusja{{=}}}}}} | ; Pełne wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|2{{=}}|z{{=}}|p{{=}}|d{{=}}}}}} ; Pełne wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|2{{=}}|za{{=}}|po{{=}}|dyskusja{{=}}}}}} }}|{{#if:{{Dopasuj|ciąg={{ROOTPAGENAME}}|wzór=^Link%u%l+2?$}}| ; Pełne pierwsze wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|2{{=}}|z{{=}}|p{{=}}|k{{=}}}}}} ; Pełne pierwsze wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|2{{=}}|za{{=}}|po{{=}}|klucz projektu{{=}}}}}} ; Pełne drugie wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|2{{=}}|z{{=}}|p{{=}}|kj{{=}}|kp{{=}}}}}} ; Pełne drugie wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|2{{=}}|za{{=}}|po{{=}}|kod języka{{=}}|kod projektu{{=}}}}}} | ; Pełne skrótowe wywołanie {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|2{{=}}|z{{=}}|p{{=}}}}}} ; Pełne wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|2{{=}}|za{{=}}|po{{=}}}}}} }}}}|{{#if:{{#invoke:Parametry|Not|{{Dopasuj|ciąg={{ROOTPAGENAME}}|wzór=Specjalna2?$}}}}|{{#if:{{Dopasuj|ciąg={{ROOTPAGENAME}}|wzór=^Link%u%l+2?$}}| ; Pełne pierwsze wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|z{{=}}|p{{=}}|k{{=}}|d{{=}}}}}} ; Pełne pierwsze wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|za{{=}}|po{{=}}|klucz projektu{{=}}|dyskusja{{=}}}}}} ; Pełne drugie wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|z{{=}}|po{{=}}|kj{{=}}|kp{{=}}|d{{=}}}}}} ; Pełne drugie wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|za{{=}}|po{{=}}|kod języka{{=}}|kod projektu{{=}}|dyskusja{{=}}}}}} | ; Pełne skrótowe wywołanie {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|z{{=}}|p{{=}}|d{{=}}}}}} ; Pełne wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|za{{=}}|po{{=}}|dyskusja{{=}}}}}} }}|{{#if:{{Dopasuj|ciąg={{ROOTPAGENAME}}|wzór=^Link%u%l+2?$}}| ; Pełne pierwsze wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|z{{=}}|p{{=}}|k{{=}}}}}} ; Pełne pierwsze wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|za{{=}}|po{{=}}|klucz projektu{{=}}}}}} ; Pełne drugie wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|z{{=}}|p{{=}}|kj{{=}}|kp{{=}}}}}} ; Pełne drugie wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|za{{=}}|po{{=}}|kod języka{{=}}|kod projektu{{=}}}}}} | ; Pełne wywołanie skrótowe {{Pre|{{s|{{LinkOgólne/skrót|{{ROOTPAGENAME}}}}|1{{=}}|z{{=}}|p{{=}}}}}} ; Pełne wywołanie {{Pre|{{s|{{ROOTPAGENAME}}|1{{=}}|za{{=}}|po{{=}}}}}} }}}}}}}} ; Parametry szablonu * {{Code|1}} - nazwa strony, do której link linkuje się{{#ifeq:{{ROOTPAGENAME}}|LinkWB|,|{{#if:{{Dopasuj|ciąg={{ROOTPAGENAME}}|wzór=[^2]$}}|, * {{Code|2}} - nazwa linku - (sugerowany),|,}}}} * {{Code|z}} (przestarzałe) lub {{Code|za}} - dokończenie nazwy linku za pomocą umieszczenia jego bezpośrednio za nazwą linku - (opcjonalny), * {{Code|p}} (przestarzałe) lub {{Code|po}} - dokończenie nazwy linku za pomocą umieszczenia jego bezpośrednio za linkiem - (opcjonalny){{#switch:{{ROOTPAGENAME}}|LinkWB=.|#default={{#if:{{Dopasuj|ciąg={{ROOTPAGENAME}}|wzór=^Link%u%l+2?$}}|, * {{Code|k}} (przestarzałe) lub {{Code|klucz projektu}} - kod projektu siostrzanego Wikibooks, ewentualnie w innej wersji językowej Wikimedia, używany zamiast {{Code|kod języka}} i {{Code|kod projektu}} - (opcjonalny), * {{Code|kj}} (przestarzałe) lub {{Code|kod języka}} - kod języka używany zamiast {{Code|klucz projektu}} - (opcjonalny), * {{Code|kp}} (przestarzałe) lub {{Code|kod projektu}} - kod projektu używany zamiast {{Code|klucz projektu}} - (opcjonalny)}}{{#switch:{{ROOTPAGENAME}}|LinkSpecjalna|LinkSpecjalna2=|LinkWB=|#default={{#if:{{#invoke:Parametry|Not|{{Dopasuj|ciąg={{ROOTPAGENAME}}|wzór=Specjalna2?$}}}}|, * {{Code|d}} (przestarzałe) lub {{Code|dyskusja}} - tłumaczy przestrzeń nazw na przestrzeń nazw dyskusji, gdy niepusty - (opcjonalny)}}}}{{#switch:{{ROOTPAGENAME}}|LinkOgólne|LinkOgólne2=, * {{Code|m}} (przestarzałe), {{Code|przestrzeń}} (niezalecana) lub {{Code|miano przestrzeni nazw}} - miano przestrzeni nazw kanoniczne lub niekanoniczne strony, dla projektu polskiego {{NAZWASERWISU|po=a|link=tak|wikipedia=tak}}, i jego siostrzanych projektów, a także dla ich wersji językowych - (opcjonalny), * {{Code|i}} (przestarzałe), {{Code|alias}} lub {{Code|alias miana przestrzeni nazw}} - alias do nazwy przestrzeni nazw, który jest wyświetlany przed nazwą strony, jeśli nie podano nazwy linku{{#ifeq:{{ROOTPAGENAME}}|LinkOgólne|&#32;i podano niepustą zmienną {{Code|wyświetl miano przestrzeni nazw}} - (opcjonalny)}}{{#ifeq:{{ROOTPAGENAME}}|LinkOgólne2|.|, * {{Code|w}} (przestarzałe), {{Code|wyświetl}} (niezalecana) lub {{Code|wyświetl miano przestrzeni nazw}} - jeśli wartość niepusta, to wyświetla nazwę przestrzeni nazw w nazwie linku - (opcjonalny),}}}}}} * {{Code|u}} (pzestarzałe) lub {{Code|uri}} - jeśli niepuste, wtedy traktuj adres w linku wewnętrznym, jako adres URL, czyli on jest tak kodowany. ---- Parametry w wersji skróconej są jedynie przestarzałe dla nazwy wersji pełnej szablonu nieprzekierowania, a nie są, gdy używamy przekierowania do tego szablonu. ---- ---- Szablon posiada też parametry: {{Parametr|bez znaczników|tak}} i {{Parametr|bez przetwarzania|tak}}, które kolejno znaczą, że bez obramowania znacznikowego {{Code|span}} kolorujące link, i bez głębszego, na siłę, przetwarzania linkowego, a także parametr {{Parametr|analiza|tak}} (lub jego skrót: {{Parametr|a|tak}}) do głębszego przetwarzania linkowego, ważniejszym od tego jest wcześniejszy ostatni parametr. == Przykłady == ; Możliwe poniższe warianty przykładów tego szablonu symbolizują na czym on polega, jak się powinno go używać.{{Hr}} {{LinkOgólne/przykłady|{{ROOTPAGENAME}}}} == Błędy == Błędy należy zgłaszać na stronie {{kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { "1": { "description": "Nazwa strony, do której link linkuje się.", "type": "wiki-page-name", "required": true }, "2": { "description": "Nazwa linku.", "type": "string", "suggested": true }, "po": { "aliases": [ "p" ], "description": "Dokończenie nazwy linku, poprzez umieszczenie tego napisu bezpośrednio po linku.", "type": "string" }, "klucz projektu": { "aliases": [ "k" ], "description": "Kod projektu siostrzanego Wikibooks, ewentualnie w innej wersji językowej Wikimedia, używany zamiast kod języka i kod projektu." }, "kod języka": { "aliases": [ "kj" ], "description": "Kod języka używany zamiast klucz projektu." }, "kod projektu": { "aliases": [ "kp" ], "description": "Kod projektu używany zamiast klucz projektu." }, "dyskusja": { "aliases": [ "d" ], "description": "Tłumaczy przestrzeń nazw na przestrzeń nazw dyskusji, gdy niepusty .", "type": "string" }, "miano przestrzeni nazw": { "aliases": [ "przestrzeń", "m" ], "description": "Miano przestrzeni nazw kanoniczne lub niekanoniczne strony, dla projektu polskiego Wikibooksa, i jego siostrzanych projektów, a także dla ich wersji językowych.", "type": "string" }, "skrót nazwy przestrzeni nazw": { "aliases": [ "skrót", "s" ], "description": "Skrót do nazwy przestrzeni nazw, który jest wyświetlany przed nazwą strony, jeśli nie podano nazwy linku i podano niepustą zmienną wyświetl miano przestrzeni nazw.", "type": "string" }, "wyświetl miano przestrzeni nazw": { "aliases": [ "wyświetl", "w" ], "description": "Jeśli wartość niepusta, to wyświetla nazwę przestrzeni nazw w nazwie linku.", "type": "string" }, "za": { "aliases": [ "z" ], "description": "Dokończenie nazwy linku, poprzez umieszczenie tego napisu bezpośrednio po nazwie linku.", "type": "string" } }, "description": "Szablon ogólny linków {{LinkOgólne}}, który jest budulcem innych szablonów tego typu, służy do budowania inteligentnych linków, kolorujących je. Szablon {{LinkOgólne}} obsługuje wszystkie poniższe parametry, szablony pochodne używają tylko niektórych. Szablony, ale typowo nie między-projektowe, obsługują wszystkie parametry, oprócz nazwy przestrzeni nazw: miano przestrzeni nazw, i wyświetlania nazwy przestrzeni nazw: wyświetl miano przestrzeni nazw, i skrótu do nazwy przestrzeni nazwy: skrót nazwy przestrzeni nazw. Szablony: {{LinkSpecjalna}}, {{LinkSpecjalna2}} itp., dodatkowo nie obsługują parametru: dyskusja. Szablon {{LinkWB}}, też nie obsługuje parametru: skrót nazwy przestrzeni nazw. Szablony linków między-projektowe nie obsługują parametrów: miano przestrzeni nazw, wyświetl miano przestrzeni nazw, skrót nazwy przestrzeni nazw, klucz projektu, kod języka i kod projektu. ", "paramOrder": [ "1", "2", "za", "po", "klucz projektu", "kod języka", "kod projektu", "dyskusja", "miano przestrzeni nazw", "skrót nazwy przestrzeni nazw", "wyświetl miano przestrzeni nazw" ] } </templatedata> == Zobacz też == ; Ogólne szablony linków inteligentnych, kolorujących linki, w zależności do jakiej kategorii one należą, w tym celu wykorzystuje projekt {{NAZWASERWISU|kod projektu=d|link=tak}}<!-- -->{{#ifeq:{{ROOTPAGENAME}}|LinkOgólne|| * {{s|LinkOgólne}} - najogólniejszy szablon linków, budulec innych szablonów linków, w tym również {{s|LinkUstęp}}, i pośrednio innych podobnych tego typu,}}<!-- -->{{#ifeq:{{ROOTPAGENAME}}|LinkOgólne2|| * {{s|LinkOgólne2}} - jest to szablon linków, oparty o szablon {{s|LinkOgólne}}, wyświetla link, przy niepodanym drugim parametrze, z nazwą przestrzeni nazw strony,}} * {{s|Link wewnętrzny}} - szablon służy do budowania linków inteligentnych, szablon nie ma parametru nazwy przestrzeni nazw, w przeciwieństwie do {{s|LinkOgólne}}, * {{s|Sekcja referencyjna}} - szablon sekcji podręczników, używana w ramach jednej książki, szablon na substronie {{Code|Wersja do druku}}, wyświetla tylko linki manewrowania po całej tej stronie, a wewnątrz podręcznika, pomiędzy jego artykułami, * {{s|LinkURL}} - szablon tworzy, pełny adres URL, na podstawie użytych parametrów. ; Szablony wydobywające linki z wikitekstu * {{s|WydobądźLinki}} - wydobywa linki wewnętrzne i zewnętrzne, jeżeli występują. ; Kategorie skojarzone z szablonem{{Nowiki|:}} * Szablon zgłasza błędy parametrów w kategorii: {{LinkKategoria2|Szablon {{ROOTPAGENAME}} do sprawdzenia}} (Liczba stron: {{Łączna_liczba_stron_w_kategoriach|Szablon {{ROOTPAGENAME}} do sprawdzenia}}). {{Szablony linków wewnątrz- i między-serwisowych}} {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> {{#if:{{Dopasuj|ciąg={{ROOTPAGENAME}}|wzór=^Link%u+$}}|{{Kategoria|Szablony linków inteligetnych z wyświetlanymi skrótowymi nazwami przestrzeni nazw}}}} {{#switch:{{ROOTPAGENAME}}|LinkWB=|#default= {{#if:{{Dopasuj|ciąg={{ROOTPAGENAME}}|wzór=^Link%u%l+2?$}}| {{#switch:{{ROOTPAGENAME}} |LinkOgólne|LinkOgólne2={{Kategoria|Szablony linków inteligentnych}} |#default={{#if:{{Dopasuj|ciąg={{ROOTPAGENAME}}|wzór=2$}} |{{Kategoria|Szablony linków inteligentnych z wyświetlanymi nieskrótowymi nazwami przestrzeni nazw}} |{{Kategoria|Szablony linków inteligentnych z niewyświetlanymi nazwami przestrzeni nazw}} }} }} {{#switch:{{ROOTPAGENAME}} | LinkOgólne | LinkGłówna | LinkWikijunior | LinkWikijunior2 | LinkProjekt | LinkProjekt2 | LinkUżytkownik | LinkUżytkownik2 = {{Kategorie | Szablony pomocne do tworzenia spisów treści, książek | Szablony stronicowe linków inteligentnych spisów rzeczy }} }} |{{#if:{{Dopasuj|ciąg={{ROOTPAGENAME}}|wzór=2$}} |{{#switch:{{ROOTPAGENAME}} | #default = {{Kategoria|Szablony linków inteligentnych, do polskojęzycznych projektów, z wyświetlanymi nazwami przestrzeni nazw}} | LinkCommonsKategoria2 | LinkMetaWikiPomoc2 | LinkMediaWikiPomoc2 | LinkMetaWikiProjekt2 | LinkMediaWikiExtension2 = {{Kategoria|Szablony linków inteligentnych, do obcojęzycznych projektów, z wyświetlanymi nazwami przestrzeni nazw}} }} |{{#switch:{{ROOTPAGENAME}} | #default = {{Kategoria|Szablony linków inteligentnych, do polskojęzycznych projektów, z niewyświetlanymi nazwami przestrzeni nazw}} | LinkEnGłówna | LinkEnWikijunior | LinkEnProjekt | LinkEnKategoria | LinkEnPediaGłówna = {{Kategoria|Szablony linków inteligentnych, do językowych projektów, z niewyświetlanymi nazwami przestrzeni nazw}} | LinkWikiaGłówna | LinkCommonsGłówna | LinkCommonsKategoria | LinkSpeciesGłówna | LinkMediaWikiGłówna | LinkMetaWikiGłówna | LinkDaneGłówna | LinkDaneProjekt | LinkSpeciesProjekt | LinkCommonsProjekt | LinkMetaWikiSpecjalna | LinkMetaWikiPomoc | LinkMetaWikiProjekt | LinkMediaWikiPomoc | LinkMediaWikiExtension = {{Kategoria|Szablony linków inteligentnych, do obcojęzycznych projektów, z niewyświetlanymi nazwami przestrzeni nazw}} }} }} }} }} </includeonly> anue0o9mtjkovn9o89c5cxjx3othywe 10 52080 541319 498596 2026-04-29T18:42:33Z Nux 1261 [[phab:T414805]] Standard Thumbnail Sizes 541319 sanitized-css text/css /* wyłącz kursywę w szablonach cytowania */ cite.citation { font-style: inherit; } /* Wsparcie dla Szablon:Cytuj */ .citation i>em { font-style: normal; } .cite-name-before { display:none!important; } .cite-name-after { display:inline!important;} .cite-name-full { display:none!important; } .cite-name-initials { display:inline!important; } .references .cite-name-before { display:inline!important; } .references .cite-name-after { display:none!important; } .references .cite-name-full { display:inline!important; } .references .cite-name-initials { display:none!important; } .cite-at-al { display:inline!important; } .citation.pmid .issn, .citation.doi .issn, .citation.pmc .issn, .citation.nourl .accessdate { display: none; } /* ikonki typu dostępu w szablonach cytowania */ .citation.open-access::before, .citation.closed-access::before, .citation.registered-access::before, .citation.limited-access::before { content: ""; background-repeat: no-repeat; background-position: left center; padding-right: 1em; background-size: 8px; } .citation.open-access::before { background-image: url("https://upload.wikimedia.org/wikipedia/commons/9/91/Open_Access_logo_green_alt2.svg"); } .citation.closed-access::before { background-image: url("https://upload.wikimedia.org/wikipedia/commons/c/c1/Closed_Access_logo_alternative.svg"); } .citation.registered-access::before, .citation.limited-access::before { background-image: url("https://upload.wikimedia.org/wikipedia/commons/b/b4/Lock-blue-alt-2.svg"); } 2gc6sm1cpblrjvvq3xay5yclkf7ul4j 10 54317 541367 535431 2026-04-30T11:20:23Z Persino 2851 /* Opis szablonu */ 541367 wikitext text/x-wiki {{Podstrona dokumentacji}} {{Lua|Sekcja referencyjna|StronicowyParser|Nazwy|Parametry|Linki}} {{Skomplikowany}} {{Szablony stronicowe}} {{#switch:{{ROOTPAGENAME}}|Sekcja referencyjna={{Skrót szablonu|sr}}|#default={{DivLinia}}}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Opis szablonu == Jest to szablon linków inteligentnych (tzw. linki inteligentne), który koloruje linki w zależności do jakiej kategorii szablon zaliczy stronę wskazaną w nim. Zestaw możliwych kodów linkowych, znajduje się na stronie {{s|Link wewnętrzny}}, w miejscu pod tabelą nawigacyjną {{s|Tabela nawigacyjna}}, według jego wikikodu opisu, w postaci linku do szablonu arkusza stylów, lub w samej tabeli w parametrze z linkami przyjmujące kolory według ich odpowiednich wartości, a obok nich znajdują się znaczniki szablonowe z właściwymi wartościami ich. == Użycie == Szablon służy do użycia na stronach danych podręczników, z linkiem do strony do nagłówka rozdziału lub do samej strony, albo na stronach wersji do druku (stworzonej z artykułów tego podręcznika), o nazwie {{Code|Wersja do druku}} lub na stronach zbiorczych złożonych z artykułów, do linkowania, w niej, do nagłówków, gdzie w ich tekstach są załadowane artykuły. == Ogólne przedstawienie szablonu == {{Pre|{{s|sr|nazwa strony}}, {{s|sr|1{{=}}nazwa strony|3{{=}}nazwa podstrony}}, {{s|sr|nazwa strony|tytuł linku w tekście}} lub {{s|sr|nazwa strony|tytuł linku w tekście|nazwa podstrony}}}} {{Pre|{{s|Sekcja referencyjna|nazwa strony}}, {{s|Sekcja referencyjna|1{{=}}nazwa strony|3{{=}}nazwa podstrony}}, {{s|Sekcja referencyjna|nazwa strony|tytuł linku w tekście}} lub {{s|Sekcja referencyjna|nazwa strony|tytuł linku w tekście|nazwa podstrony}}}} Szablon ten, gdy użyty na normalnej stronie, wstawia linka do strony (domyślnie rozdziału lub innego rodzaju sekcji, na którą jest podzielona książka). Używa się go podobnie jak zwykłego linka: <nowiki>[[nazwa strony|tytuł linku w tekście]]</nowiki>. Różnica pojawia się, gdy strona zawierająca ten szablon zostanie dołączona do strony, która ma w tytule "Wersja do druku". Wtedy szablon ten, zamiast tworzyć linka do strony, tworzy odnośnik do sekcji na tej samej stronie. === Dlaczego ten szablon === Szablon został stworzony do używania w spisach treści, oraz wewnątrz zwyczajnych stron książki jako odnośnik do sekcji (rozdziału/podrozdziału/itp.). Ideą tego szablonu było rozwiązanie pewnego problemu pojawiającego się, gdy strona zostanie wydrukowana w formie PDF-a. Normalnie, gdy spis treści zawiera linki do rozdziałów tworzonych normalnym sposobem (przez wikilinki), to w wydrukowanej formie te linki zostają odnośnikami bezwzględnymi do strony Wikibooks. Gdy użytkownik kliknie w taki link w PDF-ie, to zostanie przekierowany do przeglądarki WWW z otwartą stroną Wikibooks. Psuje to użytkowanie takiej strony, gdyż użytkownik zazwyczaj zakłada, że gdy kliknie na odnośnik w spisie treści, to ten przeniesie go na odpowiednią stronę ''wewnątrz'' PDF-a. Ten szablon rozwiązuje ten problem, przez warunkową zamianę linków do stron sekcji w linki lokalne do sekcji wewnątrz strony do druku. W niektórych generatorach PDF-a taka zamiana skutkuje tym, że takie linki umieszczone w spisach treści, powodują przeniesienie do odpowiedniej strony, a nie przeskok do strony WWW (pozostałe generatory po prostu nie generują linków w ogóle). == Opis parametrów == ; Pełne skrótowe wywołanie {{Pre|{{s|sr|{{Code|{{!(}}1{{!}}s{{)!}}}}{{=}}|{{Code|{{!(}}2{{!}}n{{)!}}}}{{=}}|{{Code|{{!(}}3{{!}}p{{)!}}}}{{=}}|{{Code|{{!(}}4{{!}}u{{)!}}}}{{=}}|{{Code|{{!(}}t{{)!}}}}{{=}}}}}} ; Pełne wywołanie {{Pre|{{s|Sekcja referencyjna|{{Code|{{!(}}1{{!}}strona{{)!}}}}{{=}}|{{Code|{{!(}}2{{!}}nazwa{{)!}}}}{{=}}|{{Code|{{!(}}3{{!}}podstrona{{)!}}}}{{=}}|{{Code|{{!(}}4{{!}}ustęp{{)!}}}}{{=}}|{{Code|{{!(}}pod-ustęp{{)!}}}}{{=}}}}}} ; Parametry * {{Code|1}}, {{Code|s}} lub {{Code|strona}} - jest to artykuł w podręczniku, ewentualnie z nagłówkiem, * {{Code|2}}, {{Code|n}} lub {{Code|nazwa}} - nazwa linku wyświetlana w artykule, * {{Code|3}}, {{Code|p}} lub {{Code|podstrona}} - podstrona dodawana do linku podczas rozważać, wtedy artykuł, będzie o jeden lub wyżej, głębiej w drzewie danej przestrzeni nazw, * {{Code|4}}. {{Code|u}} lub {{Code|ustęp}} - jeśli przyjmuje wartość niepustą, to nazwa wyświetlana linku jest jego nagłówek, jeżeli istnieje, lub jego podstrona albo sama strona, w przypadku przestrzeni nazw {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}} oraz nibyprzestrzeni nazw {{lr2|Brudnopis}}, w przestrzeni nazw {{Np|Project|link=tak}}, a także przestrzeni użytkownika {{Np|User|link=tak}}, a w przypadku nie podania nazwy strony {{Code|strona}} (lub jego skrót: {{Code|s}}) lub {{Code|1}}, to parametr {{Code|ustęp}} zachowuje się odwrotnie, wtedy nazwę strony, do której linkuje szablon, przyjmujemy domyślnie, że jest to nazwa książki, w przestrzeniach nazw w dwóch pierwszych nie widać różnicy działania tego parametru, już jest różnica w nibyprzestrzeniach nazw dwóch ostatnich, tutaj ten szablon podaje subnazwę książki, a nie jego adres, gdzie przy {{Parametr|ustęp|tak}} (lub jego synonim numerowany: {{Parametr|4|tak}}) (lub jego skrót: {{Parametr|u|tak}}) podaje cały adres, * {{Code|m}}, {{Code|od małej}} - jeśli niepuste, wyświetlany jest link od małej litery, * {{Code|d}}, {{Code|od dużej}} - jeśli niepuste, wyświetlany jest link od dużej litery, * {{Code|t}}, {{Code|pod-ustęp}} - na stronach zbiorczych skraca nazwę nagłówka, która na stronie artykułów podręcznika byłaby nazwą strony, do substrony. ---- Szablon posiada też parametry: {{Parametr|bez znaczników|tak}} i {{Parametr|bez przetwarzania|tak}}, które kolejno znaczą, że bez obramowania znacznikowego {{Code|span}} kolorujące link, i bez głębszego, na siłę, przetwarzania linkowego. == Przykłady == ; Możliwe poniższe warianty przykładów tego szablonu symbolizują na czym on polega, jak się powinno go używać. Działanie na odpowiednich stronach jest zasymulowane za pomocą parametrów pudełek. ---- ---- ; Podstawowe użycie ---- * Wikikod: {{s|sr|s{{=}}Historia}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Historia|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|o=tak}}}}}} → {{sr|s=Historia|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|o=tak}}. * Wikikod: {{s|sr|s{{=}}Alfabet grecki|p{{=}}Wstęp}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Alfabet grecki|p=Wstęp|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wstęp/Alfabet grecki|o=tak}}}}}} → {{sr|s=Alfabet grecki|p=Wstęp|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wstęp/Alfabet grecki|o=tak}}. * Wikikod: {{s|sr|s{{=}}Historia|n{{=}}Historia matematyki}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Historia|n=Historia matematyki|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|o=tak}}}}}} → {{sr|s=Historia|n=Historia matematyki|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|o=tak}}. * Wikikod: {{s|sr|s{{=}}Alfabet grecki|n{{=}}Alfabet grecki|p{{=}}Wstęp}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Alfabet grecki|n=Alfabet grecki|p=Wstęp|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wstęp/Alfabet grecki|o=tak}}}}}} → {{sr|s=Alfabet grecki|n=Alfabet grecki|p=Wstęp|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wstęp/Alfabet grecki|o=tak}}. * Wikikod: {{s|sr|s{{=}}Historia#Historia onomastyki}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Historia#Historia onomastyki|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Historia|o=tak}}}}}} → {{sr|s=Historia#Historia onomastyki|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Historia|o=tak}}. * Wikikod: {{s|sr|s{{=}}Historia#Historia onomastyki|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Historia#Historia onomastyki|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Historia|o=tak}}}}}} → {{sr|s=Historia#Historia onomastyki|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Historia|o=tak}}. * Wikikod: {{s|sr|s{{=}}#Historia onomastyki|p{{=}}Historia}} → {{Nowiki|{{WydobądźLinki|{{sr|s=#Historia onomastyki|p=Historia|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Historia|o=tak}}}}}} → {{sr|s=#Historia onomastyki|p=Historia|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Historia|o=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy/Zbiory|o=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy/Zbiory|o=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy/Zbiory|o=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy/Zbiory|o=tak}}. ---- ---- ; Przykłady {{Code|m}} i {{Code|d}} ---- * Wikikod: {{s|sr|s{{=}}Historia|m{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Historia|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|m=tak|o=tak}}}}}} → {{sr|s=Historia|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|m=tak|o=tak}}. * Wikikod: {{s|sr|s{{=}}Historia|n{{=}}historia|d{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Historia|n=historia|d=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|o=tak}}}}}} → {{sr|s=Historia|n=historia|d=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|o=tak}}. ---- ---- ---- ; Dla stron o subnazwie {{lu|Matematyka dla liceum/Wersja do druku}} dla przykładu dla strony {{lg|Matematyka dla liceum/Wersja do druku}} ---- * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|u{{=}}tak|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. ---- ---- * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|u{{=}}tak|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. ---- ---- ; Dla stron o subnazwie poszczególnych rozdziałów, tu mamy {{lg|Matematyka dla liceum/Zaczynamy}}, a jego substrona (jednocześnie rozdział) {{lu|Matematyka dla liceum/Zaczynamy}} ---- * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|u{{=}}tak|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|p{{=}}Zaczynamy|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|u{{=}}tak|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. ---- ---- ; Dla stron o subnazwie równej nazwie książki, tu mamy {{lg|Matematyka dla liceum/Matematyka dla liceum}}, a jego substrona (jednocześnie s zbiorcza) {{lu|Matematyka dla liceum/Matematyka dla liceum}} ---- * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|u{{=}}tak|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|u{{=}}tak|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. ---- ---- ---- ; Dla stron brudnopisu projektu {{lr2|Brudnopis}} lub stron w przestrzeni nazw {{Np|User|link=tak}}, dla przykładu dla artykułu {{lr2|Brudnopis/Karol Karolus/Ulice miasta Lublina/Litera Ż}} ---- * Wikikod: {{s|sr}} → {{Nowiki|{{WydobądźLinki|{{sr|nazwa przestrzeni nazw=Project|nazwa jednostki=Brudnopis/Karol Karolus/Ulice miasta Lublina/Litera Ż|o=tak}}}}}} → {{sr|nazwa przestrzeni nazw=Project|nazwa jednostki=Brudnopis/Karol Karolus/Ulice miasta Lublina/Litera Ż|o=tak}}. * Wikikod: {{s|sr|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|u=tak|nazwa przestrzeni nazw=Project|nazwa jednostki=Brudnopis/Karol Karolus/Ulice miasta Lublina/Litera Ż|o=tak}}}}}} → {{sr|u=tak|nazwa przestrzeni nazw=Project|nazwa jednostki=Brudnopis/Karol Karolus/Ulice miasta Lublina/Litera Ż|o=tak}}. == Błędy == Błędy należy zgłaszać na stronie {{kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { "strona": { "aliases": [ "1" ], "description": "Nazwa strony, ewentualnie z nagłówkiem.", "type": "wiki-page-name", "suggested": true }, "nazwa": { "aliases": [ "2" ], "description": "Nazwa wyświetlana linku.", "type": "string", "suggested": true }, "podstrona": { "aliases": [ "3" ], "description": "Podstrona podręcznika, do której ma zaliczyć, do linku, artykuł.", "type": "string" }, "ustęp": { "aliases": [ "4" ], "description": "Jeśli niepuste, gdy ma wyświetlić nagłówek strony lub podstronę.", "type": "string" } }, "description": "Szablon służy do użycia na stronach danych podręczników, z linkiem do strony do nagłówka rozdziału lub do samej strony, albo na stronach wersji do druku (stworzonej z artykułów tego podręcznika), o nazwie \"Wersja do druku\", do linkowania, w niej, do nagłówków, gdzie w ich tekstach są załadowane artykuły." } </templatedata> == Zobacz też == ; Ogólne szablony linków inteligentnych, kolorujących linki, w zależności do jakiej kategorii one należą, w tym celu wykorzystuje projekt {{NAZWASERWISU|kod projektu=d|link=tak}} * {{s|LinkOgólne}} - najogólniejszy szablon linków, budulec innych szablonów linków, w tym również {{s|LinkUstęp}}, i pośrednio innych podobnych tego typu, * {{s|LinkOgólne2}} - jest to szablon linków, oparty o szablon {{s|LinkOgólne}}, wyświetla link, przy niepodanym drugim parametrze, z nazwą przestrzeni nazw strony, * {{s|Link wewnętrzny}} - szablon służy do budowania linków inteligentnych, szablon nie ma parametru nazwy przestrzeni nazw, w przeciwieństwie do {{s|LinkOgólne}}, * {{s|LinkURL}} - szablon tworzy, pełny adres URL, na podstawie użytych parametrów. ; Szablony wydobywające linki z wikitekstu * {{s|WydobądźLinki}} - wydobywa linki wewnętrzne i zewnętrzne, jeżeli występują. {{Szablony linków wewnątrz- i między-serwisowych}} {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE I INTERWIKI PONIŻEJ TEJ LINII --> {{Kategorie | Szablony pomocne do tworzenia spisów treści, książek | Szablony na strony do druku | Szablony linków inteligentnych do ustępu | Szablony stronicowe stron zbiorczych | Szablony stronicowe linków inteligentnych spisów rzeczy }} </includeonly> qvkzb7d7pznz18n8m0fbb4adnqiagqs 541371 541367 2026-04-30T11:33:11Z Persino 2851 /* Opis szablonu */ 541371 wikitext text/x-wiki {{Podstrona dokumentacji}} {{Lua|Sekcja referencyjna|StronicowyParser|Nazwy|Parametry|Linki}} {{Skomplikowany}} {{Szablony stronicowe}} {{#switch:{{ROOTPAGENAME}}|Sekcja referencyjna={{Skrót szablonu|sr}}|#default={{DivLinia}}}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Opis szablonu == Szablon linków inteligentnych z kodami na stronie {{s|Link wewnętrzny}}, który się mieści w tabeli wywołania szablonowego {{s|Tabela nawigacyjna}} w jego parametrze, tam są też linkujące do tej samej strony, czyli do szablonu arkusza stylów, w której został wywołany, ewentualnie do jego identyfikatora danego elementu, mające kolory odpowiednie dla nich, a właściwe wartości kodów znajdują się w znaczniku szablonowym {{s|span}} obok tych odpowiednich elementów. Szablon koloruje linki w zależności do jakiej kategorii on należy, a do tego celu używa {{NAZWASERWISU|klucz projektu=d|link=tak}}. == Użycie == Szablon służy do użycia na stronach danych podręczników, z linkiem do strony do nagłówka rozdziału lub do samej strony, albo na stronach wersji do druku (stworzonej z artykułów tego podręcznika), o nazwie {{Code|Wersja do druku}} lub na stronach zbiorczych złożonych z artykułów, do linkowania, w niej, do nagłówków, gdzie w ich tekstach są załadowane artykuły. == Ogólne przedstawienie szablonu == {{Pre|{{s|sr|nazwa strony}}, {{s|sr|1{{=}}nazwa strony|3{{=}}nazwa podstrony}}, {{s|sr|nazwa strony|tytuł linku w tekście}} lub {{s|sr|nazwa strony|tytuł linku w tekście|nazwa podstrony}}}} {{Pre|{{s|Sekcja referencyjna|nazwa strony}}, {{s|Sekcja referencyjna|1{{=}}nazwa strony|3{{=}}nazwa podstrony}}, {{s|Sekcja referencyjna|nazwa strony|tytuł linku w tekście}} lub {{s|Sekcja referencyjna|nazwa strony|tytuł linku w tekście|nazwa podstrony}}}} Szablon ten, gdy użyty na normalnej stronie, wstawia linka do strony (domyślnie rozdziału lub innego rodzaju sekcji, na którą jest podzielona książka). Używa się go podobnie jak zwykłego linka: <nowiki>[[nazwa strony|tytuł linku w tekście]]</nowiki>. Różnica pojawia się, gdy strona zawierająca ten szablon zostanie dołączona do strony, która ma w tytule "Wersja do druku". Wtedy szablon ten, zamiast tworzyć linka do strony, tworzy odnośnik do sekcji na tej samej stronie. === Dlaczego ten szablon === Szablon został stworzony do używania w spisach treści, oraz wewnątrz zwyczajnych stron książki jako odnośnik do sekcji (rozdziału/podrozdziału/itp.). Ideą tego szablonu było rozwiązanie pewnego problemu pojawiającego się, gdy strona zostanie wydrukowana w formie PDF-a. Normalnie, gdy spis treści zawiera linki do rozdziałów tworzonych normalnym sposobem (przez wikilinki), to w wydrukowanej formie te linki zostają odnośnikami bezwzględnymi do strony Wikibooks. Gdy użytkownik kliknie w taki link w PDF-ie, to zostanie przekierowany do przeglądarki WWW z otwartą stroną Wikibooks. Psuje to użytkowanie takiej strony, gdyż użytkownik zazwyczaj zakłada, że gdy kliknie na odnośnik w spisie treści, to ten przeniesie go na odpowiednią stronę ''wewnątrz'' PDF-a. Ten szablon rozwiązuje ten problem, przez warunkową zamianę linków do stron sekcji w linki lokalne do sekcji wewnątrz strony do druku. W niektórych generatorach PDF-a taka zamiana skutkuje tym, że takie linki umieszczone w spisach treści, powodują przeniesienie do odpowiedniej strony, a nie przeskok do strony WWW (pozostałe generatory po prostu nie generują linków w ogóle). == Opis parametrów == ; Pełne skrótowe wywołanie {{Pre|{{s|sr|{{Code|{{!(}}1{{!}}s{{)!}}}}{{=}}|{{Code|{{!(}}2{{!}}n{{)!}}}}{{=}}|{{Code|{{!(}}3{{!}}p{{)!}}}}{{=}}|{{Code|{{!(}}4{{!}}u{{)!}}}}{{=}}|{{Code|{{!(}}t{{)!}}}}{{=}}}}}} ; Pełne wywołanie {{Pre|{{s|Sekcja referencyjna|{{Code|{{!(}}1{{!}}strona{{)!}}}}{{=}}|{{Code|{{!(}}2{{!}}nazwa{{)!}}}}{{=}}|{{Code|{{!(}}3{{!}}podstrona{{)!}}}}{{=}}|{{Code|{{!(}}4{{!}}ustęp{{)!}}}}{{=}}|{{Code|{{!(}}pod-ustęp{{)!}}}}{{=}}}}}} ; Parametry * {{Code|1}}, {{Code|s}} lub {{Code|strona}} - jest to artykuł w podręczniku, ewentualnie z nagłówkiem, * {{Code|2}}, {{Code|n}} lub {{Code|nazwa}} - nazwa linku wyświetlana w artykule, * {{Code|3}}, {{Code|p}} lub {{Code|podstrona}} - podstrona dodawana do linku podczas rozważać, wtedy artykuł, będzie o jeden lub wyżej, głębiej w drzewie danej przestrzeni nazw, * {{Code|4}}. {{Code|u}} lub {{Code|ustęp}} - jeśli przyjmuje wartość niepustą, to nazwa wyświetlana linku jest jego nagłówek, jeżeli istnieje, lub jego podstrona albo sama strona, w przypadku przestrzeni nazw {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}} oraz nibyprzestrzeni nazw {{lr2|Brudnopis}}, w przestrzeni nazw {{Np|Project|link=tak}}, a także przestrzeni użytkownika {{Np|User|link=tak}}, a w przypadku nie podania nazwy strony {{Code|strona}} (lub jego skrót: {{Code|s}}) lub {{Code|1}}, to parametr {{Code|ustęp}} zachowuje się odwrotnie, wtedy nazwę strony, do której linkuje szablon, przyjmujemy domyślnie, że jest to nazwa książki, w przestrzeniach nazw w dwóch pierwszych nie widać różnicy działania tego parametru, już jest różnica w nibyprzestrzeniach nazw dwóch ostatnich, tutaj ten szablon podaje subnazwę książki, a nie jego adres, gdzie przy {{Parametr|ustęp|tak}} (lub jego synonim numerowany: {{Parametr|4|tak}}) (lub jego skrót: {{Parametr|u|tak}}) podaje cały adres, * {{Code|m}}, {{Code|od małej}} - jeśli niepuste, wyświetlany jest link od małej litery, * {{Code|d}}, {{Code|od dużej}} - jeśli niepuste, wyświetlany jest link od dużej litery, * {{Code|t}}, {{Code|pod-ustęp}} - na stronach zbiorczych skraca nazwę nagłówka, która na stronie artykułów podręcznika byłaby nazwą strony, do substrony. ---- Szablon posiada też parametry: {{Parametr|bez znaczników|tak}} i {{Parametr|bez przetwarzania|tak}}, które kolejno znaczą, że bez obramowania znacznikowego {{Code|span}} kolorujące link, i bez głębszego, na siłę, przetwarzania linkowego. == Przykłady == ; Możliwe poniższe warianty przykładów tego szablonu symbolizują na czym on polega, jak się powinno go używać. Działanie na odpowiednich stronach jest zasymulowane za pomocą parametrów pudełek. ---- ---- ; Podstawowe użycie ---- * Wikikod: {{s|sr|s{{=}}Historia}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Historia|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|o=tak}}}}}} → {{sr|s=Historia|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|o=tak}}. * Wikikod: {{s|sr|s{{=}}Alfabet grecki|p{{=}}Wstęp}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Alfabet grecki|p=Wstęp|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wstęp/Alfabet grecki|o=tak}}}}}} → {{sr|s=Alfabet grecki|p=Wstęp|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wstęp/Alfabet grecki|o=tak}}. * Wikikod: {{s|sr|s{{=}}Historia|n{{=}}Historia matematyki}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Historia|n=Historia matematyki|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|o=tak}}}}}} → {{sr|s=Historia|n=Historia matematyki|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|o=tak}}. * Wikikod: {{s|sr|s{{=}}Alfabet grecki|n{{=}}Alfabet grecki|p{{=}}Wstęp}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Alfabet grecki|n=Alfabet grecki|p=Wstęp|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wstęp/Alfabet grecki|o=tak}}}}}} → {{sr|s=Alfabet grecki|n=Alfabet grecki|p=Wstęp|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wstęp/Alfabet grecki|o=tak}}. * Wikikod: {{s|sr|s{{=}}Historia#Historia onomastyki}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Historia#Historia onomastyki|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Historia|o=tak}}}}}} → {{sr|s=Historia#Historia onomastyki|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Historia|o=tak}}. * Wikikod: {{s|sr|s{{=}}Historia#Historia onomastyki|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Historia#Historia onomastyki|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Historia|o=tak}}}}}} → {{sr|s=Historia#Historia onomastyki|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Historia|o=tak}}. * Wikikod: {{s|sr|s{{=}}#Historia onomastyki|p{{=}}Historia}} → {{Nowiki|{{WydobądźLinki|{{sr|s=#Historia onomastyki|p=Historia|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Historia|o=tak}}}}}} → {{sr|s=#Historia onomastyki|p=Historia|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Historia|o=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy/Zbiory|o=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy/Zbiory|o=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy/Zbiory|o=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy/Zbiory|o=tak}}. ---- ---- ; Przykłady {{Code|m}} i {{Code|d}} ---- * Wikikod: {{s|sr|s{{=}}Historia|m{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Historia|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|m=tak|o=tak}}}}}} → {{sr|s=Historia|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|m=tak|o=tak}}. * Wikikod: {{s|sr|s{{=}}Historia|n{{=}}historia|d{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Historia|n=historia|d=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|o=tak}}}}}} → {{sr|s=Historia|n=historia|d=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Onomastyka/Abionim|o=tak}}. ---- ---- ---- ; Dla stron o subnazwie {{lu|Matematyka dla liceum/Wersja do druku}} dla przykładu dla strony {{lg|Matematyka dla liceum/Wersja do druku}} ---- * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|u{{=}}tak|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. ---- ---- * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|u{{=}}tak|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Wersja do druku|c=tak}}. ---- ---- ; Dla stron o subnazwie poszczególnych rozdziałów, tu mamy {{lg|Matematyka dla liceum/Zaczynamy}}, a jego substrona (jednocześnie rozdział) {{lu|Matematyka dla liceum/Zaczynamy}} ---- * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|u{{=}}tak|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|p{{=}}Zaczynamy|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|u{{=}}tak|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Zaczynamy|c=tak}}. ---- ---- ; Dla stron o subnazwie równej nazwie książki, tu mamy {{lg|Matematyka dla liceum/Matematyka dla liceum}}, a jego substrona (jednocześnie s zbiorcza) {{lu|Matematyka dla liceum/Matematyka dla liceum}} ---- * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zaczynamy/Zbiory|u{{=}}tak|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zaczynamy/Zbiory|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zaczynamy/Zbiory|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|u=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. ---- * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. * Wikikod: {{s|sr|s{{=}}Zbiory|p{{=}}Zaczynamy|u{{=}}tak|t{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|s=Zbiory|p=Zaczynamy|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}}}}} → {{sr|s=Zbiory|p=Zaczynamy|u=tak|t=tak|nazwa przestrzeni nazw=(main)|nazwa jednostki=Matematyka dla liceum/Matematyka dla liceum|c=tak}}. ---- ---- ---- ; Dla stron brudnopisu projektu {{lr2|Brudnopis}} lub stron w przestrzeni nazw {{Np|User|link=tak}}, dla przykładu dla artykułu {{lr2|Brudnopis/Karol Karolus/Ulice miasta Lublina/Litera Ż}} ---- * Wikikod: {{s|sr}} → {{Nowiki|{{WydobądźLinki|{{sr|nazwa przestrzeni nazw=Project|nazwa jednostki=Brudnopis/Karol Karolus/Ulice miasta Lublina/Litera Ż|o=tak}}}}}} → {{sr|nazwa przestrzeni nazw=Project|nazwa jednostki=Brudnopis/Karol Karolus/Ulice miasta Lublina/Litera Ż|o=tak}}. * Wikikod: {{s|sr|u{{=}}tak}} → {{Nowiki|{{WydobądźLinki|{{sr|u=tak|nazwa przestrzeni nazw=Project|nazwa jednostki=Brudnopis/Karol Karolus/Ulice miasta Lublina/Litera Ż|o=tak}}}}}} → {{sr|u=tak|nazwa przestrzeni nazw=Project|nazwa jednostki=Brudnopis/Karol Karolus/Ulice miasta Lublina/Litera Ż|o=tak}}. == Błędy == Błędy należy zgłaszać na stronie {{kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { "strona": { "aliases": [ "1" ], "description": "Nazwa strony, ewentualnie z nagłówkiem.", "type": "wiki-page-name", "suggested": true }, "nazwa": { "aliases": [ "2" ], "description": "Nazwa wyświetlana linku.", "type": "string", "suggested": true }, "podstrona": { "aliases": [ "3" ], "description": "Podstrona podręcznika, do której ma zaliczyć, do linku, artykuł.", "type": "string" }, "ustęp": { "aliases": [ "4" ], "description": "Jeśli niepuste, gdy ma wyświetlić nagłówek strony lub podstronę.", "type": "string" } }, "description": "Szablon służy do użycia na stronach danych podręczników, z linkiem do strony do nagłówka rozdziału lub do samej strony, albo na stronach wersji do druku (stworzonej z artykułów tego podręcznika), o nazwie \"Wersja do druku\", do linkowania, w niej, do nagłówków, gdzie w ich tekstach są załadowane artykuły." } </templatedata> == Zobacz też == ; Ogólne szablony linków inteligentnych, kolorujących linki, w zależności do jakiej kategorii one należą, w tym celu wykorzystuje projekt {{NAZWASERWISU|kod projektu=d|link=tak}} * {{s|LinkOgólne}} - najogólniejszy szablon linków, budulec innych szablonów linków, w tym również {{s|LinkUstęp}}, i pośrednio innych podobnych tego typu, * {{s|LinkOgólne2}} - jest to szablon linków, oparty o szablon {{s|LinkOgólne}}, wyświetla link, przy niepodanym drugim parametrze, z nazwą przestrzeni nazw strony, * {{s|Link wewnętrzny}} - szablon służy do budowania linków inteligentnych, szablon nie ma parametru nazwy przestrzeni nazw, w przeciwieństwie do {{s|LinkOgólne}}, * {{s|LinkURL}} - szablon tworzy, pełny adres URL, na podstawie użytych parametrów. ; Szablony wydobywające linki z wikitekstu * {{s|WydobądźLinki}} - wydobywa linki wewnętrzne i zewnętrzne, jeżeli występują. {{Szablony linków wewnątrz- i między-serwisowych}} {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE I INTERWIKI PONIŻEJ TEJ LINII --> {{Kategorie | Szablony pomocne do tworzenia spisów treści, książek | Szablony na strony do druku | Szablony linków inteligentnych do ustępu | Szablony stronicowe stron zbiorczych | Szablony stronicowe linków inteligentnych spisów rzeczy }} </includeonly> ch71hms2j8p44e0owkwzh1stmc31t1u 828 56418 541362 535274 2026-04-30T09:34:59Z Persino 2851 541362 Scribunto text/plain local p={}; local function NazwaKsiazkawaSilnik(frame,funkcja_nazw,tabela_nazw) if((tabela_nazw)and(tabela_nazw.namespace)and(tabela_nazw.pagename))then local nazwy_modul=require("Module:Nazwy"); return nazwy_modul[funkcja_nazw](nil,tabela_nazw); end; local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local pelna_nazwa_strony=PobierzParametr("nazwa") or PobierzParametr(1); local bez_transformacji=PobierzParametr("bez transformacji"); local funkcja=PobierzParametr("funkcja"); local funkcja_decode=PobierzParametr("funkcja decode"); local modul=PobierzParametr("moduł"); local modul_decode=PobierzParametr("moduł decode"); funkcja=parametry_modul.CzyTak(funkcja) and funkcja or ""; funkcja_decode=parametry_modul.CzyTak(funkcja_decode) and funkcja_decode or "DecodeHtml"; modul=parametry_modul.CzyTak(modul) and modul or "Książkowe"; modul_decode=parametry_modul.CzyTak(modul_decode) and modul_decode or "Html"; local czy_bez_transformacji=parametry_modul.CzyTak(bez_transformacji); local nazwy_modul=require("Module:Nazwy"); local html_modul=require("Module:Html"); local uzyskana_nazwa_jednostki= pelna_nazwa_strony and (czy_bez_transformacji and nazwy_modul[funkcja_nazw](pelna_nazwa_strony,tabela_nazw) or nazwy_modul[funkcja_nazw](require("Module:"..modul)[funkcja](require("Module:"..modul_decode)[funkcja_decode](pelna_nazwa_strony,true)),tabela_nazw) ) or (czy_bez_transformacji and nazwy_modul[funkcja_nazw](nil,tabela_nazw) or require("Module:"..modul)[funkcja](require("Module:"..modul_decode)[funkcja_decode](nazwy_modul[funkcja_nazw](nil,tabela_nazw),true)) ); return uzyskana_nazwa_jednostki; end; ---- p[""]=function(parametr) return parametr; end; p["NazwaPrzestrzeni"] = function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"NAZWAPRZESTRZENI",tabela_nazw); end; p["NazwaPrzestrzeniKsiążki"] = function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"NAZWAPRZESTRZENIKSIĄŻKI",tabela_nazw); end; p["NazwaTytułuKsiążki"] = function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"SUBNAZWAKSIĄŻKI",tabela_nazw); end; p["NazwaArtykułuKsiążki"]=function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"NAZWAARTYKUŁUKSIĄŻKI",tabela_nazw); end; ---- p["NazwaKsiążki"] = function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"NAZWAKSIĄŻKI",tabela_nazw); end; p["PełnaNazwaKsiążki"] = function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"PEŁNANAZWAKSIĄŻKI",tabela_nazw); end; p["PełnaNazwaArtykułu"] = function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"PEŁNANAZWASTRONY",tabela_nazw); end; p["NazwaArtykułu"] = function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"NAZWASTRONY",tabela_nazw); end; p["PełnaNazwaStronicowejKsiążki"]=function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; if((tabela_nazw)and(tabela_nazw.namespace)and(tabela_nazw.pagename))then local nazwy_modul=require("Module:Nazwy"); return nazwy_modul["PEŁNANAZWAKSIĄŻKI"](nil,tabela_nazw); end; --- local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local niepelna_nazwa_strony=PobierzParametr("nazwa") or PobierzParametr(1); local bez_transformacji=PobierzParametr("bez transformacji"); local funkcja=PobierzParametr("funkcja"); local funkcja_decode=PobierzParametr("funkcja decode"); local modul=PobierzParametr("moduł"); local modul_decode=PobierzParametr("moduł decode"); funkcja=parametry_modul.CzyTak(funkcja) and funkcja or ""; funkcja_decode=parametry_modul.CzyTak(funkcja_decode) and funkcja_decode or "DecodeHtml"; modul=parametry_modul.CzyTak(modul) and modul or "Książkowe"; modul_decode=parametry_modul.CzyTak(modul_decode) and modul_decode or "Html"; niepelna_nazwa_strony=niepelna_nazwa_strony and ((not bez_transformacji) and require("Module:"..modul)[funkcja](require("Module:"..modul_decode)[funkcja_decode](niepelna_nazwa_strony,true)) or niepelna_nazwa_strony) or nil; local function Parametr(strona) return{ ["nazwa"]=strona, ["bez transformacji"]=bez_transformacji, ["funkcja"]=funkcja, ["funkcja decode"]=funkcja_decode, ["moduł"]=modul, ["moduł decode"]=modul_decode, }; end; if(not niepelna_nazwa_strony)then local nazwy_modul=require("Module:Nazwy"); return (not bez_transformacji) and p["PełnaNazwaKsiążki"](Parametr(niepelna_nazwa_strony),tabela_nazw) or nazwy_modul["PEŁNANAZWAKSIĄŻKI"](niepelna_nazwa_strony,tabela_nazw); elseif(niepelna_nazwa_strony=="")then local nazwy_modul=require("Module:Nazwy"); return nazwy_modul["PEŁNANAZWAKSIĄŻKI"](niepelna_nazwa_strony,tabela_nazw); end; local dwukropek=mw.ustring.match(niepelna_nazwa_strony,"^:"); if(dwukropek)then local nazwy_modul=require("Module:Nazwy"); return nazwy_modul["PEŁNANAZWAKSIĄŻKI"](niepelna_nazwa_strony,tabela_nazw); else local nazwy_modul=require("Module:Nazwy"); local nazwa_przestrzeni=nazwy_modul["NAZWAPRZESTRZENI"](niepelna_nazwa_strony); local czy_niepelna_nazwa_strony_z_przestrzenia=(nazwa_przestrzeni~=""); if czy_niepelna_nazwa_strony_z_przestrzenia then return nazwy_modul["PEŁNANAZWAKSIĄŻKI"](niepelna_nazwa_strony,tabela_nazw); else local title_main=mw.title.makeTitle('',niepelna_nazwa_strony); if((title_main)and(title_main.exists))then return nazwy_modul["NAZWAKSIĄŻKI"](niepelna_nazwa_strony,tabela_nazw); else local nazwy_np_modul=mw.loadData("Module:Nazwy/Np"); local title_wikijunior=mw.title.makeTitle(nazwy_np_modul.Wikijunior,niepelna_nazwa_strony); if((title_wikijunior)and(title_wikijunior.exists))then return nazwy_modul["PEŁNANAZWAKSIĄŻKI"](((nazwy_np_modul.Wikijunior~="") and nazwy_np_modul.Wikijunior..":" or "")..niepelna_nazwa_strony,tabela_nazw); else local tabela_nazw2={}; local nazwa_przestrzeni=(not bez_transformacji) and p["NazwaPrzestrzeni"](Parametr(),tabela_nazw2) or nazwy_modul["NAZWAPRZESTRZENI"](nil,tabela_nazw2); local nazwa_przestrzeni_ksiazki=(not bez_transformacji) and p["NazwaPrzestrzeniKsiążki"](Parametr(),tabela_nazw2) or nazwy_modul["NAZWAPRZESTRZENIKSIĄŻKI"](nil,tabela_nazw2); local pelna_nazwa_strony=((nazwa_przestrzeni~="")and (nazwa_przestrzeni..":") or "") ..nazwa_przestrzeni_ksiazki ..((niepelna_nazwa_strony~="")and(((nazwa_przestrzeni_ksiazki~="") and "/" or "")..niepelna_nazwa_strony) or ""); return nazwy_modul["PEŁNANAZWAKSIĄŻKI"](pelna_nazwa_strony,tabela_nazw); end; end; end; end; end; return p; shww1ouzx3jxmjyph91q8lw9tsaht0b 10 56545 541368 535756 2026-04-30T11:20:55Z Persino 2851 /* Opis szablonu */ 541368 wikitext text/x-wiki {{Podstrona dokumentacji}} {{Lua|Module:Linki}} {{Skomplikowany}} {{#switch:{{ROOTPAGENAME}}|LinkURL={{Skrót szablonu|Lz}}|#default={{DivLinia}}}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Opis szablonu == Jest to szablon linków inteligentnych (tzw. linki inteligentne), który koloruje linki w zależności do jakiej kategorii szablon zaliczy stronę wskazaną w nim. Zestaw możliwych kodów linkowych, znajduje się na stronie {{s|Link wewnętrzny}}, w miejscu pod tabelą nawigacyjną {{s|Tabela nawigacyjna}}, według jego wikikodu opisu, w postaci linku do szablonu arkusza stylów, lub w samej tabeli w parametrze z linkami przyjmujące kolory według ich odpowiednich wartości, a obok nich znajdują się znaczniki szablonowe z właściwymi wartościami ich. Szablon {{s|LinkURL}} posiada wersję skróconą w postaci skrótu podanego w prawym górnym rogu strony w podwójnych nawiasach klamrowych. == Użycie == Szablon tworzy adres strony URL i tworzy z niego link o podanej nazwie wyświetlanej przez szablon. Też można bezpośrednio wsadzić do tego sam adres URL, nie za pomocą jego elementów. Jest to szablon linków inteligentnych kolorujących linki w zależności do jakiej kategorii one należą, do tego celu używa {{NAZWASERWISU|link=tak|kod projektu=d}}. Szablon tworzy link wewnętrzny, gdy podano adres projektu siostrzanego lub językowego {{NAZWASERWISU|link=w}}, bez parametrów, a link zewnętrzny, gdy są parametry, lub URL. W przypadku projektów {{NAZWASERWISU|klucz projektu=mw|link=tak}}, gdy podano parametr z wartością {{Parametr|w|w}} lub {{Parametr|w|wiki}}, to szablon generuje link zewnętrzny kolejno w postaci {{Code|../w/..}}, i {{Code|../wiki/..}}. == Skrót do szablonu == Skrót do szablonu {{s|LinkURL}} jest {{s|lz}}. == Opis parametrów == ; Pełne pierwsze wywołanie w przypadku podania strony URL {{Pre|{{s|LinkURL|strona{{=}}|wersja linku{{=}}|nazwa{{=}}|za{{=}}|po{{=}}}}}} ; Pełne drugie wywołanie, gdy strona nie jest adresem URL {{Pre|{{s|LinkURL|{{!(}}miano przestrzeni nazw{{!}}przestrzeń{{)!}}{{=}}|strona{{=}}|parametry{{=}}|nagłówek{{=}}|klucz projektu{{=}}|wersja linku{{=}}|nazwa{{=}}|za{{=}}|po{{=}}}}}} ;Pełne trzecie wywołanie, gdy strona nie jest adresem URL {{Pre|{{s|LinkURL|{{!(}}miano przestrzeni nazw{{!}}przestrzeń{{)!}}{{=}}|strona{{=}}|parametry{{=}}|nagłówek{{=}}|kod języka{{=}}|kod projektu{{=}}|wersja linku{{=}}|nazwa{{=}}|za{{=}}|po{{=}}}}}} ; Parametry, strona URL może wskazywać na jakąś wiki lub być zewnętrznym adresem do zupełnie innej wiki lub jakieś innej strony nienależącej do żadnego wiki * {{Code|f}} (przestarzałe), {{Code|przestrzeń}} lub {{Code|miano przestrzeni nazw}} - nazwa przestrzeni nazw, do której należy strona * {{Code|s}} (przestarzałe) lub {{Code|strona}} - nazwa strony, z przestrzenią nazw, kodami języka lub projektu albo nie lub nazwą strony zaczynający się od {{Code|/wiki/}} lub {{Code|/w/}}, albo jest URL (z nazwą protokołu lub nie) strony, a na projektach MediaWiki z nazwą strony z tymi pierwszymi opcjami (nazwy przestrzeni i kody), co tutaj są wymienione. * {{Code|c}} (przestarzałe) lub {{Code|parametry}} - parametry strony, * {{Code|g}} (przestarzałe) lub {{Code|nagłówek}} - nagłówek strony następujący po znaku: {{Code|#}}, * {{Code|k}} (przestarzałe) lub {{Code|klucz projektu}} - klucz projektu, używany zamiast zmiennych: {{Code|kod języka}} i {{Code|kod projektu}}, * {{Code|kj}} (przestarzałe) lub {{Code|kod języka}} - kod języka, używany zamiast zmiennej {{Code|klucz projektu}}, * {{Code|kp}} (przestarzałe) lub {{Code|kod projektu}} - kod projektu, używany zamiast zmiennej {{Code|klucz projektu}}, * {{Code|w}} (przestarzałe) lub {{Code|wersja linku}} - generuje link zewnętrzny, gdy: {{Parametr|wersja linku|w}}, w postaci: {{Code|../w/..}}, zamiast: {{Code|../wiki/..}} dla {{Parametr|wersja linku|wiki}}, a gdy {{Parametr|wersja linku}}, to generuje normalny link wewnętrzny, jeżeli nie ma on parametrów i nie jest URL, * {{Code|n}} (przestarzałe) lub {{Code|nazwa}} - nazwa wyświetlana linku, * {{Code|z}} (przestarzałe) lub {{Code|za}} - dokończenie nazwy linku, poprzez umieszczenie tego napisu bezpośrednio po nazwie linku, * {{Code|p}} (przestarzałe) lub {{Code|po}} - dokończenie nazwy linku, poprzez umieszczenie tego napisu bezpośrednio po linku, * {{Code|u}} (pzestarzałe) lub {{Code|uri}} - jeśli niepuste, wtedy traktuj adres w linku wewnętrznym, jako adres URL, czyli on jest tak kodowany. ---- Parametry w wersji skróconej są jedynie przestarzałe dla nazwy wersji pełnej szablonu {{s|LinkURL}}, a nie są, gdy używamy przekierowania do tego szablonu w postaci {{s|Lz}}. ---- ---- Jeżeli parametr {{Code|strona}} jest adresem URL, to należy ewentualnie go używać jedynie z argumentem {{Code|nazwa}}. W przypadku linków zewnętrznych nazwa linku jest tworzona automatycznie na podstawie parametru {{Code|strona}}, gdy nie podano zmiennej {{Code|nazwa}}. Jeżeli ona jest pusta, to link wyświetla automatyczny numerek, tak jak przy zwykłych tych linkach. A dla linku wewnętrznego, parametr {{Code|nazwa}}, czy jest pusty, czy nie podany, to i tak wyświetla się nazwa linku (bez numerka). ---- Szablon posiada też parametry: {{Parametr|bez znaczników|tak}} i {{Parametr|bez przetwarzania|tak}}, które kolejno znaczą, że bez obramowania znacznikowego {{Code|span}} kolorujące link, i bez głębszego, na siłę, przetwarzania linkowego, a także parametr: {{Parametr|analiza|tak}} ({{Parametr|a}}), do głębszego przetwarzania linkowego, ważniejszym od tego jest wcześniejszy ostatni parametr. == Przykłady == ; Możliwe poniższe warianty przykładów tego szablonu symbolizują na czym on polega, jak się powinno go używać.{{Hr}} * Wikikod: {{s|lz|s{{=}}Fizyka teoretyczna}} → Wynik: {{lz|s=Fizyka teoretyczna}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=Fizyka teoretyczna}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}Fizyka teoretyczna|n{{=}}Dział fizyki}} → Wynik: {{lz|s=Fizyka teoretyczna|n=Dział fizyki}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=Fizyka teoretyczna|n=Dział fizyki}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}Fizyka teoretyczna|w{{=}}w}} → Wynik: {{lz|s=Fizyka teoretyczna|w=w}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=Fizyka teoretyczna|w=w}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}Fizyka teoretyczna|w{{=}}wiki|n{{=}}Dział fizyki}} → Wynik: {{lz|s=Fizyka teoretyczna|w=wiki|n=Dział fizyki}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=Fizyka teoretyczna|w=wiki|n=Dział fizyki}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|s{{=}}/wiki/Szablon:Link wewnętrzny|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/wiki/Szablon:Link wewnętrzny|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/wiki/Szablon:Link wewnętrzny|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/wiki/Szablon:Link wewnętrzny?action{{=}}edit#Obsługa|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/wiki/Szablon:Link wewnętrzny?action=edit#Obsługa|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/wiki/Szablon:Link wewnętrzny?action=edit#Obsługa|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/w/index.php?title{{=}}Szablon:Link wewnętrzny|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/w/index.php?title=Szablon:Link wewnętrzny|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/w/index.php?title=Szablon:Link wewnętrzny|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/w/index.php?title{{=}}Szablon:Link wewnętrzny&action{{=}}edit#Obsługa|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/w/index.php?title=Szablon:Link wewnętrzny&action{{=}}edit#Obsługa|n=Szablon Link wewnętrzny}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|s{{=}}Fizyka teoretyczna|w{{=}}w|n{{=}}Dział fizyki}} → Wynik: {{lz|s=Fizyka teoretyczna|w=w|n=Dział fizyki}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=Fizyka teoretyczna|w=w|n=Dział fizyki}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/wiki/Szablon:Link wewnętrzny|w{{=}}w|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/wiki/Szablon:Link wewnętrzny|w=w|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/wiki/Szablon:Link wewnętrzny|w=w|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/wiki/Szablon:Link wewnętrzny?action{{=}}edit#Obsługa|w{{=}}w|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/wiki/Szablon:Link wewnętrzny?action=edit#Obsługa|w=w|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/wiki/Szablon:Link wewnętrzny?action=edit#Obsługa|w=w|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/w/index.php?title{{=}}Szablon:Link wewnętrzny|w{{=}}w|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/w/index.php?title=Szablon:Link wewnętrzny|w=w|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/w/index.php?title=Szablon:Link wewnętrzny|w=w|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/w/index.php?title{{=}}Szablon:Link wewnętrzny&action{{=}}edit#Obsługa|w{{=}}w|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa|w=w|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa|w=w|n=Szablon Link wewnętrzny}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|s{{=}}Fizyka teoretyczna|w{{=}}wiki|w{{=}}wiki|n{{=}}Dział fizyki}} → Wynik: {{lz|s=Fizyka teoretyczna|w=wiki|n=Dział fizyki}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=Fizyka teoretyczna|w=wiki|n=Dział fizyki}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/wiki/Szablon:Link wewnętrzny|w{{=}}wiki|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/wiki/Szablon:Link wewnętrzny|w=wiki|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/wiki/Szablon:Link wewnętrzny|w=wiki|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/wiki/Szablon:Link wewnętrzny?action{{=}}edit#Obsługa|w{{=}}wiki|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/wiki/Szablon:Link wewnętrzny?action=edit#Obsługa|w=wiki|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/wiki/Szablon:Link wewnętrzny?action=edit#Obsługa|w=wiki|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/w/index.php?title{{=}}Szablon:Link wewnętrzny|w{{=}}wiki|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/w/index.php?title=Szablon:Link wewnętrzny|w=wiki|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/w/index.php?title=Szablon:Link wewnętrzny|w=wiki|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/w/index.php?title{{=}}Szablon:Link wewnętrzny&action{{=}}edit#Obsługa|w{{=}}wiki|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa|w=wiki|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa|w=wiki|n=Szablon Link wewnętrzny}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|miano przestrzeni nazw{{=}}Project|s{{=}}FAQ/Readers|klucz projektu{{=}}en:w|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|klucz projektu=en:w|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|klucz projektu=en:w|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} * Wikikod: {{s|lz|miano przestrzeni nazw{{=}}Project|s{{=}}FAQ/Readers|kj{{=}}en|kp{{=}}w|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|kj=en|kp=w|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|kj=en|kp=w|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} {{Hr}} * Wikikod: {{s|lz|miano przestrzeni nazw{{=}}Project|s{{=}}FAQ/Readers|g{{=}}What is Wikipedia?|klucz projektu{{=}}en:w|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|g=What is Wikipedia?|klucz projektu=en:w|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|g=What is Wikipedia?|klucz projektu=en:w|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} * Wikikod: {{s|lz|miano przestrzeni nazw{{=}}Project|s{{=}}FAQ/Readers|g{{=}}What is Wikipedia?|kj{{=}}en|kp{{=}}w|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|g=What is Wikipedia?|kj=en|kp=w|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|g=What is Wikipedia?|kj=en|kp=w|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} {{Hr}} * Wikikod: {{s|lz|miano przestrzeni nazw{{=}}Project|s{{=}}FAQ/Readers|c{{=}}action{{=}}edit|g{{=}}What is Wikipedia?|klucz projektu{{=}}en:w|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|c=action=edit|g=What is Wikipedia?|klucz projektu=en:w|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|c=action=edit|g=What is Wikipedia?|klucz projektu=en:w|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} * Wikikod: {{s|lz|miano przestrzeni nazw{{=}}Project|s{{=}}FAQ/Readers|c{{=}}action{{=}}edit|g{{=}}What is Wikipedia?|kj{{=}}en|kp{{=}}w|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|c=action=edit|g=What is Wikipedia?|kj=en|kp=w|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|c=action=edit|g=What is Wikipedia?|kj=en|kp=w|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers |n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers#What_is_Wikipedia?|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers?action{{=}}edit|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers?action{{=}}edit|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers?action{{=}}edit|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers?action{{=}}edit#What_is_Wikipedia?|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers?action{{=}}edit#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers?action=edit#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/w/index.php?title{{=}}Wikipedia:FAQ/Readers|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers |n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/w/index.php?title{{=}}Wikipedia:FAQ/Readers#What_is_Wikipedia?|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/w/index.php?title{{=}}Wikipedia:FAQ/Readers&action{{=}}edit|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers&action{{=}}edit|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers&action=edit|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/w/index.php?title{{=}}Wikipedia:FAQ/Readers&action{{=}}edit#What_is_Wikipedia?|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers&action=edit#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers&action=edit#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/wiki/Archaea|n{{=}}Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/wiki/Archaea|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/wiki/Archaea|n=Gatunek bakterii Archaea}}}}}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/wiki/Archaea#Taksonawigacja|n{{=}}Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/wiki/Archaea#Taksonawigacja|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/wiki/Archaea#Taksonawigacja|n=Gatunek bakterii Archaea}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/wiki/Archaea?action{{=}}edit|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/wiki/Archaea?action=edit|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/wiki/Archaea?action=edit|n=Gatunek bakterii Archaea}}}}}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/wiki/Archaea?action{{=}}edit#Taksonawigacja|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/wiki/Archaea?action=edit#Taksonawigacja|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/wiki/Archaea?action=edit#Taksonawigacja|n=Gatunek bakterii Archaea}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/w/index.php?title{{=}}Archaea|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/w/index.php?title=Archaea|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/w/index.php?title=Archaea|n=Gatunek bakterii Archaea}}}}}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/w/index.php?title{{=}}Archaea#Taksonawigacja|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/w/index.php?title=Archaea#Taksonawigacja|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/w/index.php?title=Archaea#Taksonawigacja|n=Gatunek bakterii Archaea}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/w/index.php?title{{=}}Archaea&action{{=}}edit|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/w/index.php?title=Archaea&action=edit|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/w/index.php?title=Archaea&action=edit|n=Gatunek bakterii Archaea}}}}}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/w/index.php?title{{=}}Archaea&action{{=}}edit#Taksonawigacja|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/w/index.php?title=Archaea&action=edit#Taksonawigacja|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/w/index.php?title=Archaea&action=edit#Taksonawigacja|n=Gatunek bakterii Archaea}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|s{{=}}//lua.org.pl/5.2/manual.html|n{{=}}Język Lua 5.2}} → Wynik: {{lz|s=//lua.org.pl/5.2/manual.html|n=Język Lua 5.2}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//lua.org.pl/5.2/manual.html|n=Język Lua 5.2}}}}}} * Wikikod: {{s|lz|s{{=}}//lua.org.pl/5.2/manual.html#8.3|n{{=}}Język Lua 5.2}} → Wynik: {{lz|s=//lua.org.pl/5.2/manual.html#8.3|n=Język Lua 5.2}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//lua.org.pl/5.2/manual.html#8.3|n=Język Lua 5.2}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|s{{=}}<nowiki>http://lua.org.pl/5.2/manual.html</nowiki>|n{{=}}Język Lua 5.2}} → Wynik: {{lz|s=http://lua.org.pl/5.2/manual.html|n=Język Lua 5.2}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=http://lua.org.pl/5.2/manual.html|n=Język Lua 5.2}}}}}} * Wikikod: {{s|lz|s{{=}}<nowiki>http://lua.org.pl/5.2/manual.html#8.3</nowiki>|n{{=}}Język Lua 5.2}} → Wynik: {{lz|s=http://lua.org.pl/5.2/manual.html#8.3|n=Język Lua 5.2}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=http://lua.org.pl/5.2/manual.html#8.3|n=Język Lua 5.2}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|s{{=}}<nowiki>http://species.wikimedia.org/w/index.php?title=Archaea</nowiki>|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea|n=Gatunek bakterii Archaea}}}}}} * Wikikod: {{s|lz|s{{=}}<nowiki>http://species.wikimedia.org/w/index.php?title=Archaea#Taksonawigacja</nowiki>|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea#Taksonawigacja|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea#Taksonawigacja|n=Gatunek bakterii Archaea}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}<nowiki>http://species.wikimedia.org/w/index.php?title=Archaea&action=edit</nowiki>|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea&action=edit|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea&action=edit|n=Gatunek bakterii Archaea}}}}}} * Wikikod: {{s|lz|s{{=}}<nowiki>http://species.wikimedia.org/w/index.php?title=Archaea&action=edit#Taksonawigacja</nowiki>|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea&action=edit#Taksonawigacja|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea&action=edit#Taksonawigacja|n=Gatunek bakterii Archaea}}}}}} == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { "miano przestrzeni nazw": { "aliases": [ "przestrzeń" ], "description": "Przestrzeń nazw, do której ma zaliczyć stronę.", "type": "string", "suggested": true }, "strona": { "description": "Nazwa strony, bez przestrzeni nazw. Jeżeli parametr \"strona\" jest adresem URL, to należy ewentualnie go używać jedynie z argumentem \"nazwa\". ", "type": "wiki-page-name", "required": true }, "nagłówek": { "description": "Nagłówek strony.", "type": "string" }, "klucz projektu": { "description": "Klucz projektu, używany zamiast: \"kod języka\" i \"kod projektu\"." }, "kod języka": { "description": "Kod języka, używany zamiast \"Klucz projektu\"." }, "kod projektu": { "description": "Kod projektu, używany zamiast \"klucz projektu\"." }, "nazwa": { "description": "Nazwa wyświetlana linku.", "type": "string", "suggested": true }, "parametry": { "description": "Parametry strony.", "type": "line", "suggested": true }, "za": { "description": "Dokończenie nazwy linku, poprzez umieszczenie tego napisu bezpośrednio po nazwie linku.", "type": "string" }, "po": { "description": "Dokończenie nazwy linku, poprzez umieszczenie tego napisu bezpośrednio po linku.", "type": "string" } }, "description": "Szablon tworzy adres strony URL i tworzy z niego link o podanej nazwie wyświetlanej przez szablon. Też można bezpośrednio wsadzić do tego sam adres URL, nie za pomocą jego elementów. Jest to szablon linków inteligentnych kolorujących linki w zależności do jakiej kategorii one należą, do tego celu używa Wikidane.\n\nSzablon tworzy link wewnętrzny, gdy podano adres projektu siostrzanego lub językowego Wikibooks, bez parametrów, a link zewnętrzny, gdy są parametry, lub URL.\n\nW przypadku projektów MediaWiki, gdy podano parametr z wartością | wersja linku = w lub | wersja linku = wiki, to szablon generuje link zewnętrzny kolejno w postaci ../w/.., i ../wiki/... ", "paramOrder": [ "miano przestrzeni nazw", "strona", "parametry", "nagłówek", "klucz projektu", "kod języka", "kod projektu", "nazwa", "za", "po" ] } </templatedata> == Zobacz też == ; Ogólne szablony linków inteligentnych, kolorujących linki, w zależności do jakiej kategorii one należą, w tym celu wykorzystuje projekt {{NAZWASERWISU|kod projektu=d|link=tak}} * {{s|LinkOgólne}} - najogólniejszy szablon linków, budulec innych szablonów linków, w tym również {{s|LinkUstęp}}, i pośrednio innych podobnych tego typu, * {{s|LinkOgólne2}} - jest to szablon linków, oparty o szablon {{s|LinkOgólne}}, wyświetla link, przy niepodanym drugim parametrze, z nazwą przestrzeni nazw strony, * {{s|Link wewnętrzny}} - szablon służy do budowania linków inteligentnych, szablon nie ma parametru nazwy przestrzeni nazw, w przeciwieństwie do {{s|LinkOgólne}}, * {{s|Sekcja referencyjna}} - szablon sekcji podręczników, używana w ramach jednej książki, szablon na substronie {{Code|Wersja do druku}}, wyświetla tylko linki manewrowania po całej tej stronie, a wewnątrz podręcznika, pomiędzy jego artykułami. ; Szablony wydobywające linki z wikitekstu * {{s|WydobądźLinki}} - wydobywa linki wewnętrzne i zewnętrzne, jeżeli występują. {{Szablony linków wewnątrz- i między-serwisowych}} {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> {{Kategoria|Linki z opcją do zewnętrznych serwisów}} </includeonly> lvntmiuyj83t2wc7w25gfrobnqwer61 541372 541368 2026-04-30T11:39:01Z Persino 2851 541372 wikitext text/x-wiki {{Podstrona dokumentacji}} {{Lua|Module:Linki}} {{Skomplikowany}} {{#switch:{{ROOTPAGENAME}}|LinkURL={{Skrót szablonu|Lz}}|#default={{DivLinia}}}} <!-- DODAWAJ KATEGORIE NA DOLE STRONY --> == Opis szablonu == Szablon linków inteligentnych z kodami na stronie {{s|Link wewnętrzny}}, który się mieści w tabeli wywołania szablonowego {{s|Tabela nawigacyjna}} w jego parametrze, tam są też linkujące do tej samej strony, czyli do szablonu arkusza stylów, w której został wywołany, ewentualnie do jego identyfikatora danego elementu, mające kolory odpowiednie dla nich, a właściwe wartości kodów znajdują się w znaczniku szablonowym {{s|span}} obok tych odpowiednich elementów. Szablon koloruje linki w zależności do jakiej kategorii on należy, a do tego celu używa {{NAZWASERWISU|klucz projektu=d|link=tak}}. Szablon {{s|LinkURL}} posiada wersję skróconą w postaci skrótu podanego w prawym górnym rogu strony w podwójnych nawiasach klamrowych. == Użycie == Szablon wykorzystuje adres strony URL, protokolarny lub nie, lub adres linku wewnętrznego, i tworzy z niego link, niekoniecznie zewnętrzny, o podanej nazwie, lub nie, wyświetlanej przez szablon. Szablon tworzy link wewnętrzny, gdy podano adres projektu siostrzanego lub językowego {{NAZWASERWISU|link=w}}, bez parametrów, a link zewnętrzny, gdy są parametry, lub URL. W przypadku projektów {{NAZWASERWISU|klucz projektu=mw|link=tak}}, gdy podano parametr z wartością {{Parametr|w|w}} lub {{Parametr|w|wiki}}, to szablon generuje link zewnętrzny kolejno w postaci {{Code|../w/..}}, i {{Code|../wiki/..}}. == Skrót do szablonu == Skrót do szablonu {{s|LinkURL}} jest {{s|lz}}. == Opis parametrów == ; Pełne pierwsze wywołanie w przypadku podania strony URL {{Pre|{{s|LinkURL|strona{{=}}|wersja linku{{=}}|nazwa{{=}}|za{{=}}|po{{=}}}}}} ; Pełne drugie wywołanie, gdy strona nie jest adresem URL {{Pre|{{s|LinkURL|{{!(}}miano przestrzeni nazw{{!}}przestrzeń{{)!}}{{=}}|strona{{=}}|parametry{{=}}|nagłówek{{=}}|klucz projektu{{=}}|wersja linku{{=}}|nazwa{{=}}|za{{=}}|po{{=}}}}}} ;Pełne trzecie wywołanie, gdy strona nie jest adresem URL {{Pre|{{s|LinkURL|{{!(}}miano przestrzeni nazw{{!}}przestrzeń{{)!}}{{=}}|strona{{=}}|parametry{{=}}|nagłówek{{=}}|kod języka{{=}}|kod projektu{{=}}|wersja linku{{=}}|nazwa{{=}}|za{{=}}|po{{=}}}}}} ; Parametry, strona URL może wskazywać na jakąś wiki lub być zewnętrznym adresem do zupełnie innej wiki lub jakieś innej strony nienależącej do żadnego wiki * {{Code|f}} (przestarzałe), {{Code|przestrzeń}} lub {{Code|miano przestrzeni nazw}} - nazwa przestrzeni nazw, do której należy strona * {{Code|s}} (przestarzałe) lub {{Code|strona}} - nazwa strony, z przestrzenią nazw, kodami języka lub projektu albo nie lub nazwą strony zaczynający się od {{Code|/wiki/}} lub {{Code|/w/}}, albo jest URL (z nazwą protokołu lub nie) strony, a na projektach MediaWiki z nazwą strony z tymi pierwszymi opcjami (nazwy przestrzeni i kody), co tutaj są wymienione. * {{Code|c}} (przestarzałe) lub {{Code|parametry}} - parametry strony, * {{Code|g}} (przestarzałe) lub {{Code|nagłówek}} - nagłówek strony następujący po znaku: {{Code|#}}, * {{Code|k}} (przestarzałe) lub {{Code|klucz projektu}} - klucz projektu, używany zamiast zmiennych: {{Code|kod języka}} i {{Code|kod projektu}}, * {{Code|kj}} (przestarzałe) lub {{Code|kod języka}} - kod języka, używany zamiast zmiennej {{Code|klucz projektu}}, * {{Code|kp}} (przestarzałe) lub {{Code|kod projektu}} - kod projektu, używany zamiast zmiennej {{Code|klucz projektu}}, * {{Code|w}} (przestarzałe) lub {{Code|wersja linku}} - generuje link zewnętrzny, gdy: {{Parametr|wersja linku|w}}, w postaci: {{Code|../w/..}}, zamiast: {{Code|../wiki/..}} dla {{Parametr|wersja linku|wiki}}, a gdy {{Parametr|wersja linku}}, to generuje normalny link wewnętrzny, jeżeli nie ma on parametrów i nie jest URL, * {{Code|n}} (przestarzałe) lub {{Code|nazwa}} - nazwa wyświetlana linku, * {{Code|z}} (przestarzałe) lub {{Code|za}} - dokończenie nazwy linku, poprzez umieszczenie tego napisu bezpośrednio po nazwie linku, * {{Code|p}} (przestarzałe) lub {{Code|po}} - dokończenie nazwy linku, poprzez umieszczenie tego napisu bezpośrednio po linku, * {{Code|u}} (pzestarzałe) lub {{Code|uri}} - jeśli niepuste, wtedy traktuj adres w linku wewnętrznym, jako adres URL, czyli on jest tak kodowany. ---- Parametry w wersji skróconej są jedynie przestarzałe dla nazwy wersji pełnej szablonu {{s|LinkURL}}, a nie są, gdy używamy przekierowania do tego szablonu w postaci {{s|Lz}}. ---- ---- Jeżeli parametr {{Code|strona}} jest adresem URL, to należy ewentualnie go używać jedynie z argumentem {{Code|nazwa}}. W przypadku linków zewnętrznych nazwa linku jest tworzona automatycznie na podstawie parametru {{Code|strona}}, gdy nie podano zmiennej {{Code|nazwa}}. Jeżeli ona jest pusta, to link wyświetla automatyczny numerek, tak jak przy zwykłych tych linkach. A dla linku wewnętrznego, parametr {{Code|nazwa}}, czy jest pusty, czy nie podany, to i tak wyświetla się nazwa linku (bez numerka). ---- Szablon posiada też parametry: {{Parametr|bez znaczników|tak}} i {{Parametr|bez przetwarzania|tak}}, które kolejno znaczą, że bez obramowania znacznikowego {{Code|span}} kolorujące link, i bez głębszego, na siłę, przetwarzania linkowego, a także parametr: {{Parametr|analiza|tak}} ({{Parametr|a}}), do głębszego przetwarzania linkowego, ważniejszym od tego jest wcześniejszy ostatni parametr. == Przykłady == ; Możliwe poniższe warianty przykładów tego szablonu symbolizują na czym on polega, jak się powinno go używać.{{Hr}} * Wikikod: {{s|lz|s{{=}}Fizyka teoretyczna}} → Wynik: {{lz|s=Fizyka teoretyczna}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=Fizyka teoretyczna}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}Fizyka teoretyczna|n{{=}}Dział fizyki}} → Wynik: {{lz|s=Fizyka teoretyczna|n=Dział fizyki}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=Fizyka teoretyczna|n=Dział fizyki}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}Fizyka teoretyczna|w{{=}}w}} → Wynik: {{lz|s=Fizyka teoretyczna|w=w}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=Fizyka teoretyczna|w=w}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}Fizyka teoretyczna|w{{=}}wiki|n{{=}}Dział fizyki}} → Wynik: {{lz|s=Fizyka teoretyczna|w=wiki|n=Dział fizyki}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=Fizyka teoretyczna|w=wiki|n=Dział fizyki}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|s{{=}}/wiki/Szablon:Link wewnętrzny|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/wiki/Szablon:Link wewnętrzny|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/wiki/Szablon:Link wewnętrzny|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/wiki/Szablon:Link wewnętrzny?action{{=}}edit#Obsługa|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/wiki/Szablon:Link wewnętrzny?action=edit#Obsługa|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/wiki/Szablon:Link wewnętrzny?action=edit#Obsługa|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/w/index.php?title{{=}}Szablon:Link wewnętrzny|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/w/index.php?title=Szablon:Link wewnętrzny|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/w/index.php?title=Szablon:Link wewnętrzny|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/w/index.php?title{{=}}Szablon:Link wewnętrzny&action{{=}}edit#Obsługa|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/w/index.php?title=Szablon:Link wewnętrzny&action{{=}}edit#Obsługa|n=Szablon Link wewnętrzny}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|s{{=}}Fizyka teoretyczna|w{{=}}w|n{{=}}Dział fizyki}} → Wynik: {{lz|s=Fizyka teoretyczna|w=w|n=Dział fizyki}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=Fizyka teoretyczna|w=w|n=Dział fizyki}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/wiki/Szablon:Link wewnętrzny|w{{=}}w|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/wiki/Szablon:Link wewnętrzny|w=w|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/wiki/Szablon:Link wewnętrzny|w=w|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/wiki/Szablon:Link wewnętrzny?action{{=}}edit#Obsługa|w{{=}}w|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/wiki/Szablon:Link wewnętrzny?action=edit#Obsługa|w=w|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/wiki/Szablon:Link wewnętrzny?action=edit#Obsługa|w=w|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/w/index.php?title{{=}}Szablon:Link wewnętrzny|w{{=}}w|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/w/index.php?title=Szablon:Link wewnętrzny|w=w|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/w/index.php?title=Szablon:Link wewnętrzny|w=w|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/w/index.php?title{{=}}Szablon:Link wewnętrzny&action{{=}}edit#Obsługa|w{{=}}w|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa|w=w|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa|w=w|n=Szablon Link wewnętrzny}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|s{{=}}Fizyka teoretyczna|w{{=}}wiki|w{{=}}wiki|n{{=}}Dział fizyki}} → Wynik: {{lz|s=Fizyka teoretyczna|w=wiki|n=Dział fizyki}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=Fizyka teoretyczna|w=wiki|n=Dział fizyki}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/wiki/Szablon:Link wewnętrzny|w{{=}}wiki|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/wiki/Szablon:Link wewnętrzny|w=wiki|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/wiki/Szablon:Link wewnętrzny|w=wiki|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/wiki/Szablon:Link wewnętrzny?action{{=}}edit#Obsługa|w{{=}}wiki|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/wiki/Szablon:Link wewnętrzny?action=edit#Obsługa|w=wiki|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/wiki/Szablon:Link wewnętrzny?action=edit#Obsługa|w=wiki|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/w/index.php?title{{=}}Szablon:Link wewnętrzny|w{{=}}wiki|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/w/index.php?title=Szablon:Link wewnętrzny|w=wiki|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/w/index.php?title=Szablon:Link wewnętrzny|w=wiki|n=Szablon Link wewnętrzny}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}/w/index.php?title{{=}}Szablon:Link wewnętrzny&action{{=}}edit#Obsługa|w{{=}}wiki|n{{=}}Szablon Link wewnętrzny}} → Wynik: {{lz|s=/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa|w=wiki|n=Szablon Link wewnętrzny}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa|w=wiki|n=Szablon Link wewnętrzny}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|miano przestrzeni nazw{{=}}Project|s{{=}}FAQ/Readers|klucz projektu{{=}}en:w|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|klucz projektu=en:w|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|klucz projektu=en:w|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} * Wikikod: {{s|lz|miano przestrzeni nazw{{=}}Project|s{{=}}FAQ/Readers|kj{{=}}en|kp{{=}}w|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|kj=en|kp=w|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|kj=en|kp=w|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} {{Hr}} * Wikikod: {{s|lz|miano przestrzeni nazw{{=}}Project|s{{=}}FAQ/Readers|g{{=}}What is Wikipedia?|klucz projektu{{=}}en:w|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|g=What is Wikipedia?|klucz projektu=en:w|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|g=What is Wikipedia?|klucz projektu=en:w|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} * Wikikod: {{s|lz|miano przestrzeni nazw{{=}}Project|s{{=}}FAQ/Readers|g{{=}}What is Wikipedia?|kj{{=}}en|kp{{=}}w|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|g=What is Wikipedia?|kj=en|kp=w|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|g=What is Wikipedia?|kj=en|kp=w|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} {{Hr}} * Wikikod: {{s|lz|miano przestrzeni nazw{{=}}Project|s{{=}}FAQ/Readers|c{{=}}action{{=}}edit|g{{=}}What is Wikipedia?|klucz projektu{{=}}en:w|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|c=action=edit|g=What is Wikipedia?|klucz projektu=en:w|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|c=action=edit|g=What is Wikipedia?|klucz projektu=en:w|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} * Wikikod: {{s|lz|miano przestrzeni nazw{{=}}Project|s{{=}}FAQ/Readers|c{{=}}action{{=}}edit|g{{=}}What is Wikipedia?|kj{{=}}en|kp{{=}}w|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|c=action=edit|g=What is Wikipedia?|kj=en|kp=w|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|miano przestrzeni nazw=Project|s=FAQ/Readers|c=action=edit|g=What is Wikipedia?|kj=en|kp=w|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers |n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers#What_is_Wikipedia?|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers?action{{=}}edit|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers?action{{=}}edit|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers?action{{=}}edit|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers?action{{=}}edit#What_is_Wikipedia?|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers?action{{=}}edit#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/wiki/Wikipedia:FAQ/Readers?action=edit#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/w/index.php?title{{=}}Wikipedia:FAQ/Readers|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers |n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/w/index.php?title{{=}}Wikipedia:FAQ/Readers#What_is_Wikipedia?|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/w/index.php?title{{=}}Wikipedia:FAQ/Readers&action{{=}}edit|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers&action{{=}}edit|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers&action=edit|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} * Wikikod: {{s|lz|s{{=}}//en.wikipedia.org/w/index.php?title{{=}}Wikipedia:FAQ/Readers&action{{=}}edit#What_is_Wikipedia?|n{{=}}Pomoc dla użytkowników angielskiej Wikipedii}} → Wynik: {{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers&action=edit#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//en.wikipedia.org/w/index.php?title=Wikipedia:FAQ/Readers&action=edit#What_is_Wikipedia?|n=Pomoc dla użytkowników angielskiej Wikipedii}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/wiki/Archaea|n{{=}}Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/wiki/Archaea|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/wiki/Archaea|n=Gatunek bakterii Archaea}}}}}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/wiki/Archaea#Taksonawigacja|n{{=}}Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/wiki/Archaea#Taksonawigacja|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/wiki/Archaea#Taksonawigacja|n=Gatunek bakterii Archaea}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/wiki/Archaea?action{{=}}edit|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/wiki/Archaea?action=edit|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/wiki/Archaea?action=edit|n=Gatunek bakterii Archaea}}}}}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/wiki/Archaea?action{{=}}edit#Taksonawigacja|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/wiki/Archaea?action=edit#Taksonawigacja|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/wiki/Archaea?action=edit#Taksonawigacja|n=Gatunek bakterii Archaea}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/w/index.php?title{{=}}Archaea|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/w/index.php?title=Archaea|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/w/index.php?title=Archaea|n=Gatunek bakterii Archaea}}}}}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/w/index.php?title{{=}}Archaea#Taksonawigacja|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/w/index.php?title=Archaea#Taksonawigacja|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/w/index.php?title=Archaea#Taksonawigacja|n=Gatunek bakterii Archaea}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/w/index.php?title{{=}}Archaea&action{{=}}edit|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/w/index.php?title=Archaea&action=edit|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/w/index.php?title=Archaea&action=edit|n=Gatunek bakterii Archaea}}}}}} * Wikikod: {{s|lz|s{{=}}//species.wikimedia.org/w/index.php?title{{=}}Archaea&action{{=}}edit#Taksonawigacja|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=//species.wikimedia.org/w/index.php?title=Archaea&action=edit#Taksonawigacja|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//species.wikimedia.org/w/index.php?title=Archaea&action=edit#Taksonawigacja|n=Gatunek bakterii Archaea}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|s{{=}}//lua.org.pl/5.2/manual.html|n{{=}}Język Lua 5.2}} → Wynik: {{lz|s=//lua.org.pl/5.2/manual.html|n=Język Lua 5.2}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//lua.org.pl/5.2/manual.html|n=Język Lua 5.2}}}}}} * Wikikod: {{s|lz|s{{=}}//lua.org.pl/5.2/manual.html#8.3|n{{=}}Język Lua 5.2}} → Wynik: {{lz|s=//lua.org.pl/5.2/manual.html#8.3|n=Język Lua 5.2}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=//lua.org.pl/5.2/manual.html#8.3|n=Język Lua 5.2}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|s{{=}}<nowiki>http://lua.org.pl/5.2/manual.html</nowiki>|n{{=}}Język Lua 5.2}} → Wynik: {{lz|s=http://lua.org.pl/5.2/manual.html|n=Język Lua 5.2}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=http://lua.org.pl/5.2/manual.html|n=Język Lua 5.2}}}}}} * Wikikod: {{s|lz|s{{=}}<nowiki>http://lua.org.pl/5.2/manual.html#8.3</nowiki>|n{{=}}Język Lua 5.2}} → Wynik: {{lz|s=http://lua.org.pl/5.2/manual.html#8.3|n=Język Lua 5.2}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=http://lua.org.pl/5.2/manual.html#8.3|n=Język Lua 5.2}}}}}} {{Hr}}{{Hr}} * Wikikod: {{s|lz|s{{=}}<nowiki>http://species.wikimedia.org/w/index.php?title=Archaea</nowiki>|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea|n=Gatunek bakterii Archaea}}}}}} * Wikikod: {{s|lz|s{{=}}<nowiki>http://species.wikimedia.org/w/index.php?title=Archaea#Taksonawigacja</nowiki>|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea#Taksonawigacja|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea#Taksonawigacja|n=Gatunek bakterii Archaea}}}}}} {{Hr}} * Wikikod: {{s|lz|s{{=}}<nowiki>http://species.wikimedia.org/w/index.php?title=Archaea&action=edit</nowiki>|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea&action=edit|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea&action=edit|n=Gatunek bakterii Archaea}}}}}} * Wikikod: {{s|lz|s{{=}}<nowiki>http://species.wikimedia.org/w/index.php?title=Archaea&action=edit#Taksonawigacja</nowiki>|n{{=}}Gatunek bakterii Archaea}} → Wynik: {{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea&action=edit#Taksonawigacja|n=Gatunek bakterii Archaea}} → Kod: {{Nowiki|{{WydobądźLinki|{{lz|s=http://species.wikimedia.org/w/index.php?title=Archaea&action=edit#Taksonawigacja|n=Gatunek bakterii Archaea}}}}}} == Błędy == Błędy należy zgłaszać na stronie {{Kwestie techniczne}}. == Parametry szablonu ({{Strukturyzacja Wizualnego Edytora}}) == <templatedata> { "params": { "miano przestrzeni nazw": { "aliases": [ "przestrzeń" ], "description": "Przestrzeń nazw, do której ma zaliczyć stronę.", "type": "string", "suggested": true }, "strona": { "description": "Nazwa strony, bez przestrzeni nazw. Jeżeli parametr \"strona\" jest adresem URL, to należy ewentualnie go używać jedynie z argumentem \"nazwa\". ", "type": "wiki-page-name", "required": true }, "nagłówek": { "description": "Nagłówek strony.", "type": "string" }, "klucz projektu": { "description": "Klucz projektu, używany zamiast: \"kod języka\" i \"kod projektu\"." }, "kod języka": { "description": "Kod języka, używany zamiast \"Klucz projektu\"." }, "kod projektu": { "description": "Kod projektu, używany zamiast \"klucz projektu\"." }, "nazwa": { "description": "Nazwa wyświetlana linku.", "type": "string", "suggested": true }, "parametry": { "description": "Parametry strony.", "type": "line", "suggested": true }, "za": { "description": "Dokończenie nazwy linku, poprzez umieszczenie tego napisu bezpośrednio po nazwie linku.", "type": "string" }, "po": { "description": "Dokończenie nazwy linku, poprzez umieszczenie tego napisu bezpośrednio po linku.", "type": "string" } }, "description": "Szablon tworzy adres strony URL i tworzy z niego link o podanej nazwie wyświetlanej przez szablon. Też można bezpośrednio wsadzić do tego sam adres URL, nie za pomocą jego elementów. Jest to szablon linków inteligentnych kolorujących linki w zależności do jakiej kategorii one należą, do tego celu używa Wikidane.\n\nSzablon tworzy link wewnętrzny, gdy podano adres projektu siostrzanego lub językowego Wikibooks, bez parametrów, a link zewnętrzny, gdy są parametry, lub URL.\n\nW przypadku projektów MediaWiki, gdy podano parametr z wartością | wersja linku = w lub | wersja linku = wiki, to szablon generuje link zewnętrzny kolejno w postaci ../w/.., i ../wiki/... ", "paramOrder": [ "miano przestrzeni nazw", "strona", "parametry", "nagłówek", "klucz projektu", "kod języka", "kod projektu", "nazwa", "za", "po" ] } </templatedata> == Zobacz też == ; Ogólne szablony linków inteligentnych, kolorujących linki, w zależności do jakiej kategorii one należą, w tym celu wykorzystuje projekt {{NAZWASERWISU|kod projektu=d|link=tak}} * {{s|LinkOgólne}} - najogólniejszy szablon linków, budulec innych szablonów linków, w tym również {{s|LinkUstęp}}, i pośrednio innych podobnych tego typu, * {{s|LinkOgólne2}} - jest to szablon linków, oparty o szablon {{s|LinkOgólne}}, wyświetla link, przy niepodanym drugim parametrze, z nazwą przestrzeni nazw strony, * {{s|Link wewnętrzny}} - szablon służy do budowania linków inteligentnych, szablon nie ma parametru nazwy przestrzeni nazw, w przeciwieństwie do {{s|LinkOgólne}}, * {{s|Sekcja referencyjna}} - szablon sekcji podręczników, używana w ramach jednej książki, szablon na substronie {{Code|Wersja do druku}}, wyświetla tylko linki manewrowania po całej tej stronie, a wewnątrz podręcznika, pomiędzy jego artykułami. ; Szablony wydobywające linki z wikitekstu * {{s|WydobądźLinki}} - wydobywa linki wewnętrzne i zewnętrzne, jeżeli występują. {{Szablony linków wewnątrz- i między-serwisowych}} {{BrClear}} <includeonly><!-- ++++ DODAWAJ KATEGORIE PONIŻEJ TEJ LINII --> {{Kategoria|Linki z opcją do zewnętrznych serwisów}} </includeonly> jj97hiqxw11fjl4yyrb9qcbwtn610o2 2 59165 541320 447391 2026-04-29T22:48:02Z James500 34604 /* */ Fix page 541320 wikitext text/x-wiki This is my user page. {{Babel|en}} [[en:User:James500]] 1einvldyja8zkhkgkrozmbovaf2muyv 828 59681 541310 541305 2026-04-29T15:50:02Z Persino 2851 541310 Scribunto text/plain local p={}; function p.TYTAN(frame) local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); end; return p; s6whkop3nmc8qyxs7f3nwuj2urnks44 10 60949 541347 495085 2026-04-30T07:20:06Z Persino 2851 541347 sanitized-css text/css .babel > .babel-wiersz:only-child{ margin-top:0; margin-bottom:0; } .babel > .babel-wiersz:first-child:not(:last-child){ margin-top:0; margin-bottom:3px; } .babel > .babel-wiersz:last-child:not(:last-child){ margin-top:3px; margin-bottom:0; } .babel > .babel-wiersz:not(:first-child):not(:last-child){ margin-top:3px; margin-bottom:3px; } /*{{Kategoria|Szablony - arkusze stylów}}*/ 6czd6a6mt5zqndfcuyzajvg87h0ncro 4 63010 541357 540633 2026-04-30T08:27:41Z Persino 2851 /* Zestaw nazw przestrzeni nazw na aktualnym projekcie */ 541357 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Rozdział|{{ld2|Nazwy}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Rozdział|Koniec}} }}</noinclude> {{Spis treści}} Kod modułu znajduje się na stronie {{ld2|Nazwy}}. Ten moduł służy do określania nazw poszczególnych nazw przestrzeni nazw na projekcie polskim {{NAZWASERWISU|link=tak|wikipedia=tak}}, jak i innych siostrzanych projektów, a także buduje referencje linkujące do poszczególnych stron wyjaśniające kwestie przestrzeni nazw, a także do projektów lokujące do stron opisujące poszczególne projekty, na różnych wersjach językowych, serwisu: {{NAZWASERWISU|link=tak|klucz projektu=w|wikipedia=tak}}, lub do stron głównych poszczególnych projektów siostrzanych, w tym do tego projektu. == Wprowadzenie do funkcji nazw == === Wywołanie modułu === Moduł wywołujemy poprzez napisanie kwestii: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); </syntaxhighlight> === Definicje funkcji w module === Funkcje w module są zdefiniowane lub można zdefiniować, co jest uwidocznione w tej dokumentacji, w postaci różnych możliwości: <syntaxhighlight lang="lua"> local m={}; ... function m.Nazwa_funkcji(...) ... end; m.Nazwa_funkcji=function(...) ... end; m["Nazwa funkcji"]=function(...) ... end; ... return m; </syntaxhighlight> Funkcje można definiować na trzy możliwe sposoby według ramki powyżej, a w tych definicjach ciało funkcji i jego parametry pozostaje niezmienne. === Zestaw nazw przestrzeni nazw na aktualnym projekcie i jego wersjach siostrzanych === ==== Zestaw nazw przestrzeni nazw na aktualnym projekcie ==== Tabela przedstawia zestaw nazw przestrzeni, po polsku, dostępne na polskim {{Code|{{NAZWASERWISU|link=tak|po=ie}}}} wraz z ich nazwami kanonicznymi (w języku angielskim), wraz z ich numerami {{Code|id}}, ze stronami odniesienia, które są widoczne i użyte w szablonie {{s|Np}} (i w funkcji {{m|Nazwy|Np|{{Code|<nazwa przestrzeni nazw>}}|link{{=}}tak|wyspecjalizowana{{=}}tak}}) przy pomocy parametru {{Parametr|link|tak}}. {{Tabela|klasa=wikitable tekst-centruj-td|klasa op=tabela-strona|pozycja=centruj|liczba wierszy=25|liczba kolumn=8 | tytuł = Przestrzenie nazw{{Br}} (dla każdej przedmiotowej przestrzeni jest przestrzeń dyskusji z nr n+1) | komórka 1_1 = Przestrzeń przedmiotowa | nagłówek 1_1 = tak | kolumny 1_1 = 4 | komórka 1_5 = Przestrzeń dyskusji | nagłówek 1_5 = tak | kolumny 1_5 = 4 | komórka 2_1 = Nazwa kanoniczna | nagłówek 2_1 = tak | komórka 2_2 = Nazwa niekanoniczna | nagłówek 2_2 = tak | komórka 2_3 = Id | nagłówek 2_3 = tak | komórka 2_4 = Odniesienie | nagłówek 2_4 = tak | komórka 2_5 = Nazwa kanoniczna | nagłówek 2_5 = tak | komórka 2_6 = Nazwa niekanoniczna| nagłówek 2_6 = tak | komórka 2_7 = Id| nagłówek 2_7 = tak | komórka 2_8 = Odniesienie | nagłówek 2_8 = tak | komórka 3_1 = Przestrzenie nazw główne | nagłówek 3_1 = tak | kolumny 3_1 = 7 | komórka 3_8 = {{lpp2|Strona dyskusji}} | wiersze 3_8 = 23 | komórka 4_1 = - | komórka 4_2 = - | komórka 4_3 = 0 | wiersze 4_3 = 2| komórka 4_4 = {{lp2|Jak edytować artykuły}} | wiersze 4_4 = 2 | komórka 4_5 = Talk | wiersze 4_5 = 2 | komórka 4_6 = Dyskusja | wiersze 4_6 = 2 | komórka 4_7 = 1 | wiersze 4_7 = 2 | komórka 5_1 = (main) | komórka 5_2 = (główna) | komórka 6_1 = Wikijunior | komórka 6_2 = Wikijunior | komórka 6_3 = 104 | komórka 6_4 = {{lj2|Strona główna}} | komórka 6_5 = Wikijunior talk | komórka 6_6 = Dyskusja Wikijuniora | komórka 6_7 = 105 | komórka 7_1 = File | komórka 7_2 = Plik | komórka 7_3 = 6 | komórka 7_4 = {{lpp2|Ilustrowanie}} | komórka 7_5 = File talk | komórka 7_6 = Dyskusja pliku | komórka 7_7 = 7 | komórka 8_1 = Category | komórka 8_2 = Kategoria | komórka 8_3 = 14 | komórka 8_4 = {{lpp2|Kategorie}} | komórka 8_5 = Category talk | komórka 8_6 = Dyskusja kategorii | komórka 8_7 = 15 | komórka 9_1 = Przestrzenie nazw meta | nagłówek 9_1 = tak | kolumny 9_1 = 7 | komórka 10_1 = User | wiersze 10_1 = 2 | komórka 10_2 = Wikipedyst(a&#124;ka) | komórka 10_3 = 2 | wiersze 10_3 = 2 |komórka 10_4 = {{lpr2|Strona użytkownika}} | wiersze 10_4 = 2 | komórka 10_5 = User talk | wiersze 10_5 = 2 | komórka 10_6 = Dyskusja wikipedyst(y&#124;ki) | komórka 10_7 = 3 | wiersze 10_7 = 2 | komórka 11_2 = Użytkowni(k&#124;czka) | komórka 11_6 = Dyskusja użytkowni(ka&#124;czki) | komórka 12_1 = Wikibooks | komórka 12_2 = Wikibooks | komórka 12_3 = 4 | wiersze 12_3 = 3 | komórka 12_4 = {{lk2|Metastrony Wikibooks}} | wiersze 12_4 = 3 | komórka 12_5 = Wikibooks talk | komórka 12_6 = Dyskusja wikibooks | komórka 12_7 = 5 | wiersze 12_7 = 3 | komórka 13_1 = Project | komórka 13_2 = Projekt | komórka 13_5 = Project talk | komórka 13_6 = Dyskusja projektu | komórka 14_1 = - | komórka 14_2 = WB | komórka 14_5 = - | komórka 14_6 = - | komórka 15_1 = Help | komórka 15_2 = Pomoc | komórka 15_3 = 12 | komórka 15_4 = {{lp2|Spis treści}} | komórka 15_5 = Help talk | komórka 15_6 = Dyskusja pomocy | komórka 15_7 = 13 | komórka 16_1 = Przestrzenie nazw techniczne | nagłówek 16_1 = tak | kolumny 16_1 = 7 | komórka 17_1 = MediaWiki | komórka 17_2 = MediaWiki | komórka 17_3 = 8 | komórka 17_4 = {{lpp2|Przestrzeń nazw/MediaWiki}} | komórka 17_5 = MediaWiki talk | komórka 17_6 = Dyskusja MediaWiki | komórka 17_7 = 9 | komórka 18_1 = Template | komórka 18_2 = Szablon | komórka 18_3 = 10 | komórka 18_4 = {{lr2|Szablony}} | komórka 18_5 = Template talk | komórka 18_6 = Dyskusja szablonu | komórka 18_7 = 11 | komórka 19_1 = Module | komórka 19_2 = Moduł | komórka 19_3 = 828 | komórka 19_4 = {{lpr2|Lua}} | komórka 19_5 = Module talk | komórka 19_6 = Dyskusja modułu | komórka 19_7 = 829 | komórka 20_1 = Przestrzenie nazw wirtualne | nagłówek 20_1 = tak | kolumny 20_1 = 7 | komórka 21_1 = Special | komórka 21_2 = Specjalna | komórka 21_3 = -1 | komórka 21_4 = {{lc2|Strony specjalne}} | komórka 21_5 = - | scal 21_5 = 2 3 | komórka 22_1 = Media | komórka 22_2 = Media | komórka 22_3 = -2 | komórka 22_4 = {{lpp2|Ilustrowanie}} | komórka 23_1 = Przestrzenie nazw definiowane | nagłówek 23_1 = tak | kolumny 23_1 = 7 | komórka 24_1 = Portal | komórka 24_2 = Portal | komórka 24_3 = - | komórka 24_4 = {{lr|Przestrzenie nazw}} | wiersze 24_4 = 2 | komórka 24_5 = Portal talk | komórka 24_6 = Dyskusja portalu | komórka 24_7 = - | komórka 25_1 = Wikiproject | komórka 25_2 = Wikiprojekt | komórka 25_3 = - | komórka 25_5 = Wikiproject talk | komórka 25_6 = Dyskusja wikiprojektu | komórka 25_7 = - }} Tabela ta przedstawiana jest względem modułu {{m|Nazwy}}. W niej widać nieznane, lub znane o nieznanych nazwach, przestrzenie dla projektu {{NAZWASERWISU|wikipedia=tak|link=tak}}, ale znane dla tego modułu. Tabela przedstawia nazwy kanoniczne i niekanoniczne oraz ich numery {{Code|id}} przedstawiające numery przestrzeni nazw, jako rózne przedstawienia tej samej przestrzeni. Można tłumaczyć pomiędzy nimi. Za pomocą powyższej tabeli możemy transformować przestrzeń na przedmiotową lub dyskusji, zakładając, że one nie transformują tego samego na to samo, co też jest możliwe. Niektóre przestrzenie zależą od półci użytkownika, jak przestrzeń: {{Np|User|link=tak}}, i względem tego szablonu, tzn.: {{s|Np}} lub funkcji: {{m|Nazwy|Np}}, są one względem siebie równoważne oraz przedstawiają tą samą przestrzeń nazw. Tabela też przedstawia przestrzenie nazw definiowane, bez numerów {{Code|id}}, które są wzorowane i są obecne na polski projekcie {{NAZWASERWISU|link=tak|klucz projektu=w}}. ==== Zestaw nazw przestrzeni nazw na wersjach siostrzanych polskiego Wikibooks'a ==== Tabela przedstawia zestawienie w module {{m|Nazwy/przestrzenie}} dla tabeli {{Code|s.charakterystyczne_przestrzenie_nazw}}, która obrazuje dane dotyczące niektórych przestrzeni nazw, ewentualnie dla niektórych wersji językowych (projektów językowych), dla niektórych projektów lokalnych samego projektu {{Code|Wikibooks}} oraz jego niektórych wersji językowych i projektów siostrzanych. {{Tabela|klasa=wikitable tekst-centruj-td|klasa op=tabela-strona|pozycja=centruj|liczba wierszy=31|liczba kolumn=8 | komórka 1_1 = Kod projetu | nagłówek 1_1 = tak | wiersze 1_1 = 2 | komórka 1_2 = Nazwa wiki | nagłówek 1_2 = 2 | wiersze 1_2 = 2 | komórka 1_3 = Kod języka | nagłówek 1_3 = tak | wiersze 1_3 = 2 | komórka 1_4 = Nazwa kanoniczna | nagłówek 1_4 = tak | wiersze 1_4 = 2 | komórka 1_5 = Przestrzeń przedmiotowa | nagłówek 1_5 = tak | kolumny 1_5 = 2 | komórka 1_7 = Przestrzeń dyskusji | nagłówek 1_7 = tak | kolumny 1_7 = 2 | komórka 2_5 = Nazwa | nagłówek 2_5 = tak | komórka 2_6 = Aliasy | nagłówek 2_6 = tak | komórka 2_7 = Nazwa | nagłówek 2_7 = tak | komórka 2_8 = Aliasy | nagłówek 2_8 = tak | komórka 3_1 = Projekty niejęzykowe | nagłówek 3_1 = tak | kolumny 3_1 = 8 | komórka 4_1 = c | komórka 4_2 = Commons | komórka 4_3 = - | kolumny 4_3 = 6 | komórka 5_1 = species | komórka 5_2 = Wikispecies | komórka 5_3 = - | kolumny 5_3 = 6 | komórka 6_1 = d | komórka 6_2 = Wikidata | komórka 6_3 = en | komórka 6_4 = Property | komórka 6_5 = Property | komórka 6_6 = - | komórka 6_7 = Property talk | komórka 6_8 = - | komórka 7_1 = m | komórka 7_2 = Meta | komórka 7_3 = - | kolumny 7_3 = 6 | komórka 8_1 = mw | wiersze 8_1 = 2 | komórka 8_2 = Project | wiersze 8_2 = 2 | komórka 8_3 = en | komórka 8_4 = Extension | wiersze 8_4 = 2 | komórka 8_5 = Extension | komórka 8_6 = - | wiersze 8_6 = 2 | komórka 8_7 = Extension talk | komórka 8_8 = - | wiersze 8_8 = 2 | komórka 9_3 = pl | komórka 9_5 = Rozszerzenie | komórka 9_7 = Dyskusja rozszerzenia | komórka 10_1 = wikimania | komórka 10_2 = Wikimania | komórka 10_3 = - | kolumny 10_3 = 6 | komórka 11_1 = Projekty językowe | nagłówek 11_1 = tak | kolumny 11_1 = 8 | komórka 12_1 = w | wiersze 12_1 = 4 | komórka 12_2 = Wikipedia | wiersze 12_2 = 4 | komórka 12_3 = pl | wiersze 12_3 = 4 | komórka 12_4 = Project | komórka 12_5 = Wikipedia | komórka 12_6 = WP | komórka 12_7 = Dyskusja wikipedii | komórka 12_8 = - | komórka 13_4 = User | komórka 13_5 = Wikipedysta | komórka 13_6 = Użytkownik | komórka 13_7 = Dyskusja wikipedysty | komórka 13_8 = Dyskusja użytkownika | komórka 14_4 = Portal | komórka 14_5 = Portal | komórka 14_6 = - | komórka 14_7 = Dyskusja portalu | komórka 14_8 = - | komórka 15_4 = Wikiproject | komórka 15_5 = Wikiprojekt | komórka 15_6 = - | komórka 15_7 = Dyskusja wikiprojektu | komórka 15_8 = - | komórka 16_1 = b | wiersze 16_1 = 5 | komórka 16_2 = Wikibooks | wiersze 16_2 = 5 | komórka 16_3 = pl | wiersze 16_3 = 3 | komórka 16_4 = Project | komórka 16_5 = Wikibooks | komórka 16_6 = WB | komórka 16_7 = Dyskusja Wikibooks | komórka 16_8 = - | komórka 17_4 = User | komórka 17_5 = Wikipedysta | komórka 17_6 = Użytkownik | komórka 17_7 = Dyskusja wikipedysty | komórka 17_8 = Dyskusja użytkownika | komórka 18_4 = Wikijunior | komórka 18_5 = Wikijunior | komórka 18_6 = - | komórka 18_7 = Dyskusja Wikijuniora | komórka 18_8 = - | komórka 19_3 = en | wiersze 19_3 = 2 | komórka 19_4 = Project | komórka 19_5 = Wikibooks | komórka 19_6 = - | komórka 19_7 = Wikibooks talk | komórka 19_8 = - | komórka 20_4 = Wikijunior | komórka 20_5 = Wikijunior | komórka 20_6 = - | komórka 20_7 = Wikijunior | komórka 20_8 = - | komórka 21_1 = wikt | wiersze 21_1 = 2 | komórka 21_2 = Wiktionary | wiersze 21_2 = 2 | komórka 21_3 = pl | wiersze 21_3 = 2 | komórka 21_4 = Project | komórka 21_5 = Wikisłownik | komórka 21_6 = - | komórka 21_7 = Dyskusja Wikisłownika | komórka 21_8 = - | komórka 22_4 = User | komórka 22_5 = Wikisłownikarz | komórka 22_6 = Użytkownik | komórka 22_7 = Dyskusja wikisłownikarza | komórka 22_8 = Dyskusja użytkownika | komórka 23_1 = q | wiersze 23_1 = 2 | komórka 23_2 = Wikiquote | wiersze 23_2 = 2 | komórka 23_3 = pl | wiersze 23_3 = 2 | komórka 23_4 = Project | komórka 23_5 = Wikicytaty | komórka 23_6 = - | komórka 23_7 = Dyskusja Wikicytatów | komórka 23_8 = - | komórka 24_4 = User | komórka 24_5 = Użytkownik | komórka 24_6 = - | komórka 24_7 = Dyskusja użytkownika | komórka 24_8 = | komórka 25_1 = s | wiersze 25_1 = 2 | komórka 25_2 = Wikisource | wiersze 25_2 = 2 | komórka 25_3 = pl | wiersze 25_3 = 2 | komórka 25_4 = Project | komórka 25_5 = Wikiźródła | komórka 25_6 = - | komórka 25_7 = Dyskusja Wikiźródeł | komórka 25_8 = - | komórka 26_4 = User | komórka 26_5 = Wikiskryba | komórka 26_6 = Użytkownik | komórka 26_7 = Dyskusja wikiskryby | komórka 26_8 = Dyskusja użytkownika | komórka 27_1 = voy | wiersze 27_1 = 2 | komórka 27_2 = Wikivoyage | wiersze 27_2 = 2 | komórka 27_3 = pl | wiersze 27_3 = 2 | komórka 27_4 = Project | komórka 27_5 = Wikipodróże | komórka 27_6 = - | komórka 27_7 = Dyskusja Wikipodróży | komórka 27_8 = - | komórka 28_4 = User | komórka 28_5 = Użytkownik | komórka 28_6 = - | komórka 28_7 = Dyskusja użytkownika | komórka 28_8 = - | komórka 29_1 = n | wiersze 29_1 = 2 | komórka 29_2 = Wikinews | wiersze 29_2 = 2| komórka 29_3 = pl | wiersze 29_3 = 2 | komórka 29_4 = Project | komórka 29_5 = Wikinews | komórka 29_6 = - | komórka 29_7 = Dyskusja Wikinews | komórka 29_8 = - | komórka 30_4 = User | komórka 30_5 = Wikireporter | komórka 30_6 = Uzytkownik | komórka 30_7 = Dyskusja wikireportera | komórka 30_8 = Dyskusja użytkownika | komórka 31_1 = v | komórka 31_2 = Wikiversity | komórka 31_3 = - | kolumny 31_3 = 6 }} Tabela zawiera tylko ponadpodstawowe przestrzenie nazw z rożnych projektów, językowych lub nie, albo nie zawiera ich wcale, wtedy te przestrzeni są generowane na podstawie przy pomocy elementu tabeli {{Code|{{!(}}"wiki"{{)!}}}}, w tej tabeli jest to kolumna {{Code|Nazwa wiki}} - ta nazwa jest wykorzystana do tworzenia nazwy przestrzenie niekanonicznej przestrzeni nazw projektu. Przestrzenie podstawowe są takie same dla wszystkich projektów, tylko nazwy kanoniczne się nie zmieniają, a nazwy niekanoniczne są specyficzne dla danego języka projektu. Wersje językowe tych tabeli angielskich projektów zawierają tylko nazwy kanoniczne, które są tożsame z tymi niekanonicznymi. Ta tabela jest wykorzystywana przez szablon {{s|NpDane}} do tłumaczenia {{Code|id}} lub nazwy kanonicznej, na niekanoniczną, jeżeli istnieje, a jeżeli nie, to zamiast nazwy niekanonicznej wyświetlana jest nazwa kanoniczna. Można też tłumaczyć nazwę kanoniczną, czy niekanoniczną, na numer {{Code|id}}, ten numer jest uzyskiwany, dzięki szablonowi {{s|Np}}. Tak się dzieje, bo: {{s|NpDane}} i {{s|Np}}, mają względem siebie wspólne nazwy przestrzeni nazw kanoniczne o takich samych {{Code|id}}, ale o ogólnie innych nazwach niekanonicznych. Nazwy polskie, jako odpowiedni nazw angielskich różnych przestrzeni nazw, na innych projektach obcojęzycznych, można przetłumaczyć na polski względem tabelek powyżej, znając jedynie ich nazwy kanoniczne. Do tego celu używamy parametru {{Parametr|po polsku|tak}}. == Obsługiwane kody projektów lokalnych projektów siostrzanych {{NAZWASERWISU|link=tak|wikipedia=tak}} i ich pełne nazwy == {{Tabela|klasa=wikitable tekst-centruj-td|pozycja=prawo|liczba wierszy=14|liczba kolumn=2 | nagłówek 1 = kod projektu | nagłówek 2 = Pełna nazwa projektu | komórka 1_1 = w | komórka 1_2 = {{NAZWASERWISU|link=tak|klucz projektu=w}} | komórka 2_1 = b | komórka 2_2 = {{NAZWASERWISU|link=tak|klucz projektu=b}} | komórka 3_1 = wikt | komórka 3_2 = {{NAZWASERWISU|link=tak|klucz projektu=wikt}} | komórka 4_1 = q | komórka 4_2 = {{NAZWASERWISU|link=tak|klucz projektu=q}} | komórka 5_1 = s | komórka 5_2 = {{NAZWASERWISU|link=tak|klucz projektu=s}} | komórka 6_1 = voy | komórka 6_2 = {{NAZWASERWISU|link=tak|klucz projektu=voy}} | komórka 7_1 = n | komórka 7_2 = {{NAZWASERWISU|link=tak|klucz projektu=n}} | komórka 8_1 = v | komórka 8_2 = {{NAZWASERWISU|link=tak|klucz projektu=v}} | komórka 9_1 = commons | komórka 9_2 = {{NAZWASERWISU|link=tak|klucz projektu=commons}} | komórka 10_1 = wikispecies | komórka 10_2 = {{NAZWASERWISU|link=tak|klucz projektu=wikispecies}} | komórka 11_1 = d | komórka 11_2 = {{NAZWASERWISU|link=tak|klucz projektu=d}} | komórka 12_1 = mw | komórka 12_2 = {{NAZWASERWISU|link=tak|klucz projektu=mw}} | komórka 13_1 = m | komórka 13_2 = {{NAZWASERWISU|link=tak|klucz projektu=m}} | komórka 14_1 = wikimania | komórka 14_2 = {{NAZWASERWISU|link=tak|klucz projektu=wikimania}} }} Kody projektów przedstawiają kody projektów, jakie można włożyć do szablonu {{s|NpDane}}, czyli {{Parametr|kod projektu}}, nie wliczając: {{Parametr|kod jezyka}}, jak również do {{Parametr|klucz projektu}}, do którego można włożyć kombinację kodów języka i projektów, lub pojedynczy kod. Te kody natomiast nie można umieścić w szablonie {{s|Np}}, bo one tam się nie nadają, bo on tego nie używa. Szablon {{s|NAZWASERWISU|link{{=}}tak|kod jezyka{{=}}|kod projektu{{=}}|klucz projektu{{=}}}} (ale tutaj bez kodów języka, czy języków), użyty w tabelce, też zawiera te kody, użyty przy pomocy pary, lub pojedynczego parametru, przedstawia nazwy projektów wraz z referencjami do odpowiednich stron głównych. Strony ich główne sa ściągnięte za pomocą projektu: {{NAZWASERWISU|link=tak|klucz projektu=d}}, przy pomocy biblioteki i w niej funkcji: {{m|Wiki|WikidaneOdpowiednikStrony|nazwa strony{{=}}|kod języka{{=}}|kod projektu{{=}}|klucz projektu{{=}}|kod języka bazy{{=}}|kod projektu bazy{{=}}|klucz projektu bazy{{=}}}}. Zamiast: {{Parametr|klucz projektu}}, można użyć: {{Parametr|kod języka}} i {{Parametr|kod projektu}}, oraz odwrotnie, podobnie jest z ich wersjami dotyczące bazy. Nazwę strony: {{Parametr|nazwa strony}}, tłumaczonymi z projektu bazy przy pomocy kodów projektu i języka, na inny projekt operujący innymi kodami. W szczególnym przypadku możemy użyć tłumaczenia tożsamościowego. Tak właśnie działa właśnie ten szablon, o którym wspomnieliśmy. Strony w tym szablonie są tłumaczone przy pomocy, wychodząc od strony głównej: {{lr2|Strona główna}}, transformując je na inne projekty, tak je podawaliśmy w tej wspomnianej tabelce. Kody projektów, to nie jest to samo, co języka, projekty, to takie coś jak kod projektru {{NAZWASERWISU|klucz projektu=w|wikipedia=tak}}, a kod języka to przedstawia język, dzięki któremu poruzumiejemy się na pojekcie i w którym on jest właśnie pisany,jak {{Code|pl}} lub {{Code|en}}, ich użhywamy poprzez przedstawienie: {{Parametr|kod języka|en}} lub {{Parametr|klucz projektu|en:w}} (tutaj używamy wraz kodem projektu, lub bez niego w postaci: {{Parametr|klucz projektu|en}}, w tym pierwszy przenosimy się do angielskiej {{NAZWASERWISU|Wikipedii|link=tak|klucz projektu=en:w}}, albo w tym drugim przypadku do angielskiego: {{NAZWASERWISU|link=tak|po=a|klucz projektu=en:b}}. == Strony projektowe, użyte do tłumaczenia niektówych przestrzeni przedmiotowychna inne języki, z postaci kanonicznej (jako w nazwie angielskiej) do niekanonicznej (specyficznej dla projektu) == {{Tabela|klasa=wikitable tekst-centruj-td|pozycja=prawo|liczba wierszy=9|liczba kolumn=2 | nagłówek 1 = Nazwa kanoniczna | nagłówek 2 = Strona | komórka 1_1 = Project | komórka 1_2 ={{lr2|Administratorzy}} | komórka 2_1 = Help | komórka 2_2 = {{lp2|Spis treści}} | komórka 3_1 = Template | komórka 3_2 = {{ls2|Ek}} | komórka 4_1 = Module | komórka 4_2 = {{ld2|Wikidane}} | komórka 5_1 = Category | komórka 5_2 = {{lk2|Szablony}} | komórka 6_1 = Wikijunior | komórka 6_2 = {{lj2|Strona główna}} | komórka 7_1 = Portal | komórka 7_2 = {{lpt2|Matematyka}} | komórka 8_1 = Wikiproject | komórka 8_2 = {{lpw2|Matematyka}} | komórka 9_1 = Special | komórka 9_2 ={{lc2|Strony specjalne}} }} Nazwy projektowe, inne niż o nazwach kanonicznych: {{Np|Project|link=tak|nazwij projektem=tak|kanoniczna=tak}} i {{Np|Wikijunior|link=tak|kanoniczna=tak}}, są tłumaczone względem polskiej {{NAZWASERWISU|link=w|klucz projektu=w|Wikipedii}}, a pozostałe, względem polskiego {{NAZWASERWISU|link=tak}}. Tłumaczymy nazwy kanoniczne na niekanoniczne, specyficzne dla danego projektu. Można też tłumaczyć nazwy niekanoniczne z jednego języka na drugi, ale względem nazw kanonicznych. Do tłumaczenia nazw wykorzystujemy szablon {{s|NpDane}} (a nie {{s|Np}}). == Spis treści funkcji nazw == Oto jest spis treści w czterech częściach (tomach), przedstawiające różne funkcje w bibliotece (module {{lpg|Lua}} w {{lpr|Lua|Scribunto}}): * {{lr|Moduły/Nazwy/Tom I|Nazwy - Tom I}} - szablony: {{s|Np}}, {{s|NpDane}} i {{s|NAZWASERWISU}} i użyte do ich definicji funkcje biblioteczne, * {{lr|Moduły/Nazwy/Tom II|Nazwy - Tom II}} - szablony i procedury przestrzeni nazw i nazw stron, * {{lr|Moduły/Nazwy/Tom III|Nazwy - Tom III}} - wydzielanie z pełnej nazwy strony i liczenie różnych nazw z połączonych z mniejszych składowych, * {{lr|Moduły/Nazwy/Tom IV|Nazwy - Tom IV}} - szablony i funkcje: nazw książkowych stron i nazw przestrzeni tworów książkowych, oraz liczenie przy wykorzystywaniu tych konstrukcji, nazw sub- książki i strony, także nazwy stron korzeni (podstaw strony). Te części opisują różne funkcje wraz z parametrami, z przykładowymi użyciami w ich odpowiednikach szablonowych, które dodatkowo, w przeciwieństwie do funkcji bibliotecznych, mają walidacje błędów. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 82l3wfix3nragi2l00y151seeio3q4k 541358 541357 2026-04-30T08:29:35Z Persino 2851 541358 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Rozdział|{{ld2|Nazwy}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Rozdział|Koniec}} }}</noinclude> {{Spis treści}} Kod modułu znajduje się na stronie {{ld2|Nazwy}}. Ten moduł służy do określania nazw poszczególnych nazw przestrzeni nazw na projekcie polskim {{NAZWASERWISU|link=tak|wikipedia=tak}}, jak i innych siostrzanych projektów, a także buduje referencje linkujące do poszczególnych stron wyjaśniające kwestie przestrzeni nazw, a także do projektów lokujące do stron opisujące poszczególne projekty, na różnych wersjach językowych, serwisu: {{NAZWASERWISU|link=tak|klucz projektu=w|wikipedia=tak}}, lub do stron głównych poszczególnych projektów siostrzanych, w tym do tego projektu. == Wprowadzenie do funkcji nazw == === Wywołanie modułu === Moduł wywołujemy poprzez napisanie kwestii: <syntaxhighlight lang="lua"> local nazwy_modul=require("Module:Nazwy"); </syntaxhighlight> === Definicje funkcji w module === Funkcje w module są zdefiniowane lub można zdefiniować, co jest uwidocznione w tej dokumentacji, w postaci różnych możliwości: <syntaxhighlight lang="lua"> local m={}; ... function m.Nazwa_funkcji(...) ... end; m.Nazwa_funkcji=function(...) ... end; m["Nazwa funkcji"]=function(...) ... end; ... return m; </syntaxhighlight> Funkcje można definiować na trzy możliwe sposoby według ramki powyżej, a w tych definicjach ciało funkcji i jego parametry pozostaje niezmienne. === Zestaw nazw przestrzeni nazw na aktualnym projekcie i jego wersjach siostrzanych === ==== Zestaw nazw przestrzeni nazw na aktualnym projekcie ==== Tabela przedstawia zestaw nazw przestrzeni, po polsku, dostępne na polskim {{Code|{{NAZWASERWISU|link=tak|po=ie}}}} wraz z ich nazwami kanonicznymi (w języku angielskim), wraz z ich numerami {{Code|id}}, ze stronami odniesienia, które są widoczne i użyte w szablonie {{s|Np}} (i w funkcji {{m|Nazwy|Np|{{Code|<nazwa przestrzeni nazw>}}|link{{=}}tak|wyspecjalizowana{{=}}tak}}) przy pomocy parametru {{Parametr|link|tak}}. {{Tabela|klasa=wikitable tekst-centruj-td|klasa op=tabela-strona|pozycja=centruj|liczba wierszy=25|liczba kolumn=8 | tytuł = Przestrzenie nazw{{Br}} (dla każdej przedmiotowej przestrzeni jest przestrzeń dyskusji z nr n+1) | komórka 1_1 = Przestrzeń przedmiotowa | nagłówek 1_1 = tak | kolumny 1_1 = 4 | komórka 1_5 = Przestrzeń dyskusji | nagłówek 1_5 = tak | kolumny 1_5 = 4 | komórka 2_1 = Nazwa kanoniczna | nagłówek 2_1 = tak | komórka 2_2 = Nazwa niekanoniczna | nagłówek 2_2 = tak | komórka 2_3 = Id | nagłówek 2_3 = tak | komórka 2_4 = Odniesienie | nagłówek 2_4 = tak | komórka 2_5 = Nazwa kanoniczna | nagłówek 2_5 = tak | komórka 2_6 = Nazwa niekanoniczna| nagłówek 2_6 = tak | komórka 2_7 = Id| nagłówek 2_7 = tak | komórka 2_8 = Odniesienie | nagłówek 2_8 = tak | komórka 3_1 = Przestrzenie nazw główne | nagłówek 3_1 = tak | kolumny 3_1 = 7 | komórka 3_8 = {{lpp2|Strona dyskusji}} | wiersze 3_8 = 23 | komórka 4_1 = - | komórka 4_2 = - | komórka 4_3 = 0 | wiersze 4_3 = 2| komórka 4_4 = {{lp2|Jak edytować artykuły}} | wiersze 4_4 = 2 | komórka 4_5 = Talk | wiersze 4_5 = 2 | komórka 4_6 = Dyskusja | wiersze 4_6 = 2 | komórka 4_7 = 1 | wiersze 4_7 = 2 | komórka 5_1 = (main) | komórka 5_2 = (główna) | komórka 6_1 = Wikijunior | komórka 6_2 = Wikijunior | komórka 6_3 = 104 | komórka 6_4 = {{lj2|Strona główna}} | komórka 6_5 = Wikijunior talk | komórka 6_6 = Dyskusja Wikijuniora | komórka 6_7 = 105 | komórka 7_1 = File | komórka 7_2 = Plik | komórka 7_3 = 6 | komórka 7_4 = {{lpp2|Ilustrowanie}} | komórka 7_5 = File talk | komórka 7_6 = Dyskusja pliku | komórka 7_7 = 7 | komórka 8_1 = Category | komórka 8_2 = Kategoria | komórka 8_3 = 14 | komórka 8_4 = {{lpp2|Kategorie}} | komórka 8_5 = Category talk | komórka 8_6 = Dyskusja kategorii | komórka 8_7 = 15 | komórka 9_1 = Przestrzenie nazw meta | nagłówek 9_1 = tak | kolumny 9_1 = 7 | komórka 10_1 = User | wiersze 10_1 = 2 | komórka 10_2 = Wikipedyst(a&#124;ka) | komórka 10_3 = 2 | wiersze 10_3 = 2 |komórka 10_4 = {{lpr2|Strona użytkownika}} | wiersze 10_4 = 2 | komórka 10_5 = User talk | wiersze 10_5 = 2 | komórka 10_6 = Dyskusja wikipedyst(y&#124;ki) | komórka 10_7 = 3 | wiersze 10_7 = 2 | komórka 11_2 = Użytkowni(k&#124;czka) | komórka 11_6 = Dyskusja użytkowni(ka&#124;czki) | komórka 12_1 = Wikibooks | komórka 12_2 = Wikibooks | komórka 12_3 = 4 | wiersze 12_3 = 3 | komórka 12_4 = {{lk2|Metastrony Wikibooks}} | wiersze 12_4 = 3 | komórka 12_5 = Wikibooks talk | komórka 12_6 = Dyskusja wikibooks | komórka 12_7 = 5 | wiersze 12_7 = 3 | komórka 13_1 = Project | komórka 13_2 = Projekt | komórka 13_5 = Project talk | komórka 13_6 = Dyskusja projektu | komórka 14_1 = - | komórka 14_2 = WB | komórka 14_5 = - | komórka 14_6 = - | komórka 15_1 = Help | komórka 15_2 = Pomoc | komórka 15_3 = 12 | komórka 15_4 = {{lp2|Spis treści}} | komórka 15_5 = Help talk | komórka 15_6 = Dyskusja pomocy | komórka 15_7 = 13 | komórka 16_1 = Przestrzenie nazw techniczne | nagłówek 16_1 = tak | kolumny 16_1 = 7 | komórka 17_1 = MediaWiki | komórka 17_2 = MediaWiki | komórka 17_3 = 8 | komórka 17_4 = {{lpp2|Przestrzeń nazw/MediaWiki}} | komórka 17_5 = MediaWiki talk | komórka 17_6 = Dyskusja MediaWiki | komórka 17_7 = 9 | komórka 18_1 = Template | komórka 18_2 = Szablon | komórka 18_3 = 10 | komórka 18_4 = {{lr2|Szablony}} | komórka 18_5 = Template talk | komórka 18_6 = Dyskusja szablonu | komórka 18_7 = 11 | komórka 19_1 = Module | komórka 19_2 = Moduł | komórka 19_3 = 828 | komórka 19_4 = {{lpr2|Lua}} | komórka 19_5 = Module talk | komórka 19_6 = Dyskusja modułu | komórka 19_7 = 829 | komórka 20_1 = Przestrzenie nazw wirtualne | nagłówek 20_1 = tak | kolumny 20_1 = 7 | komórka 21_1 = Special | komórka 21_2 = Specjalna | komórka 21_3 = -1 | komórka 21_4 = {{lc2|Strony specjalne}} | komórka 21_5 = - | scal 21_5 = 2 3 | komórka 22_1 = Media | komórka 22_2 = Media | komórka 22_3 = -2 | komórka 22_4 = {{lpp2|Ilustrowanie}} | komórka 23_1 = Przestrzenie nazw definiowane | nagłówek 23_1 = tak | kolumny 23_1 = 7 | komórka 24_1 = Portal | komórka 24_2 = Portal | komórka 24_3 = - | komórka 24_4 = {{lr|Przestrzenie nazw}} | wiersze 24_4 = 2 | komórka 24_5 = Portal talk | komórka 24_6 = Dyskusja portalu | komórka 24_7 = - | komórka 25_1 = Wikiproject | komórka 25_2 = Wikiprojekt | komórka 25_3 = - | komórka 25_5 = Wikiproject talk | komórka 25_6 = Dyskusja wikiprojektu | komórka 25_7 = - }} Tabela ta przedstawiana jest względem modułu {{m|Nazwy}}. W niej widać nieznane, lub znane o nieznanych nazwach, przestrzenie dla projektu {{NAZWASERWISU|wikipedia=tak|link=tak}}, ale znane dla tego modułu. Tabela przedstawia nazwy kanoniczne i niekanoniczne oraz ich numery {{Code|id}} przedstawiające numery przestrzeni nazw, jako różne przedstawienia tej samej przestrzeni. Można tłumaczyć pomiędzy nimi. Za pomocą powyższej tabeli możemy transformować przestrzeń na przedmiotową lub dyskusji, zakładając, że one nie transformują tego samego na to samo, co też jest możliwe. Niektóre przestrzenie zależą od półci użytkownika, jak przestrzeń: {{Np|User|link=tak}}, i względem tego szablonu, tzn.: {{s|Np}} lub funkcji: {{m|Nazwy|Np}}, są one względem siebie równoważne oraz przedstawiają tą samą przestrzeń nazw. Tabela też przedstawia przestrzenie nazw definiowane, bez numerów {{Code|id}}, które są wzorowane i są obecne na polski projekcie {{NAZWASERWISU|link=tak|klucz projektu=w}}. ==== Zestaw nazw przestrzeni nazw na wersjach siostrzanych polskiego Wikibooks'a ==== Tabela przedstawia zestawienie w module {{m|Nazwy/przestrzenie}} dla tabeli {{Code|s.charakterystyczne_przestrzenie_nazw}}, która obrazuje dane dotyczące niektórych przestrzeni nazw, ewentualnie dla niektórych wersji językowych (projektów językowych), dla niektórych projektów lokalnych samego projektu {{Code|Wikibooks}} oraz jego niektórych wersji językowych i projektów siostrzanych. {{Tabela|klasa=wikitable tekst-centruj-td|klasa op=tabela-strona|pozycja=centruj|liczba wierszy=31|liczba kolumn=8 | komórka 1_1 = Kod projetu | nagłówek 1_1 = tak | wiersze 1_1 = 2 | komórka 1_2 = Nazwa wiki | nagłówek 1_2 = 2 | wiersze 1_2 = 2 | komórka 1_3 = Kod języka | nagłówek 1_3 = tak | wiersze 1_3 = 2 | komórka 1_4 = Nazwa kanoniczna | nagłówek 1_4 = tak | wiersze 1_4 = 2 | komórka 1_5 = Przestrzeń przedmiotowa | nagłówek 1_5 = tak | kolumny 1_5 = 2 | komórka 1_7 = Przestrzeń dyskusji | nagłówek 1_7 = tak | kolumny 1_7 = 2 | komórka 2_5 = Nazwa | nagłówek 2_5 = tak | komórka 2_6 = Aliasy | nagłówek 2_6 = tak | komórka 2_7 = Nazwa | nagłówek 2_7 = tak | komórka 2_8 = Aliasy | nagłówek 2_8 = tak | komórka 3_1 = Projekty niejęzykowe | nagłówek 3_1 = tak | kolumny 3_1 = 8 | komórka 4_1 = c | komórka 4_2 = Commons | komórka 4_3 = - | kolumny 4_3 = 6 | komórka 5_1 = species | komórka 5_2 = Wikispecies | komórka 5_3 = - | kolumny 5_3 = 6 | komórka 6_1 = d | komórka 6_2 = Wikidata | komórka 6_3 = en | komórka 6_4 = Property | komórka 6_5 = Property | komórka 6_6 = - | komórka 6_7 = Property talk | komórka 6_8 = - | komórka 7_1 = m | komórka 7_2 = Meta | komórka 7_3 = - | kolumny 7_3 = 6 | komórka 8_1 = mw | wiersze 8_1 = 2 | komórka 8_2 = Project | wiersze 8_2 = 2 | komórka 8_3 = en | komórka 8_4 = Extension | wiersze 8_4 = 2 | komórka 8_5 = Extension | komórka 8_6 = - | wiersze 8_6 = 2 | komórka 8_7 = Extension talk | komórka 8_8 = - | wiersze 8_8 = 2 | komórka 9_3 = pl | komórka 9_5 = Rozszerzenie | komórka 9_7 = Dyskusja rozszerzenia | komórka 10_1 = wikimania | komórka 10_2 = Wikimania | komórka 10_3 = - | kolumny 10_3 = 6 | komórka 11_1 = Projekty językowe | nagłówek 11_1 = tak | kolumny 11_1 = 8 | komórka 12_1 = w | wiersze 12_1 = 4 | komórka 12_2 = Wikipedia | wiersze 12_2 = 4 | komórka 12_3 = pl | wiersze 12_3 = 4 | komórka 12_4 = Project | komórka 12_5 = Wikipedia | komórka 12_6 = WP | komórka 12_7 = Dyskusja wikipedii | komórka 12_8 = - | komórka 13_4 = User | komórka 13_5 = Wikipedysta | komórka 13_6 = Użytkownik | komórka 13_7 = Dyskusja wikipedysty | komórka 13_8 = Dyskusja użytkownika | komórka 14_4 = Portal | komórka 14_5 = Portal | komórka 14_6 = - | komórka 14_7 = Dyskusja portalu | komórka 14_8 = - | komórka 15_4 = Wikiproject | komórka 15_5 = Wikiprojekt | komórka 15_6 = - | komórka 15_7 = Dyskusja wikiprojektu | komórka 15_8 = - | komórka 16_1 = b | wiersze 16_1 = 5 | komórka 16_2 = Wikibooks | wiersze 16_2 = 5 | komórka 16_3 = pl | wiersze 16_3 = 3 | komórka 16_4 = Project | komórka 16_5 = Wikibooks | komórka 16_6 = WB | komórka 16_7 = Dyskusja Wikibooks | komórka 16_8 = - | komórka 17_4 = User | komórka 17_5 = Wikipedysta | komórka 17_6 = Użytkownik | komórka 17_7 = Dyskusja wikipedysty | komórka 17_8 = Dyskusja użytkownika | komórka 18_4 = Wikijunior | komórka 18_5 = Wikijunior | komórka 18_6 = - | komórka 18_7 = Dyskusja Wikijuniora | komórka 18_8 = - | komórka 19_3 = en | wiersze 19_3 = 2 | komórka 19_4 = Project | komórka 19_5 = Wikibooks | komórka 19_6 = - | komórka 19_7 = Wikibooks talk | komórka 19_8 = - | komórka 20_4 = Wikijunior | komórka 20_5 = Wikijunior | komórka 20_6 = - | komórka 20_7 = Wikijunior | komórka 20_8 = - | komórka 21_1 = wikt | wiersze 21_1 = 2 | komórka 21_2 = Wiktionary | wiersze 21_2 = 2 | komórka 21_3 = pl | wiersze 21_3 = 2 | komórka 21_4 = Project | komórka 21_5 = Wikisłownik | komórka 21_6 = - | komórka 21_7 = Dyskusja Wikisłownika | komórka 21_8 = - | komórka 22_4 = User | komórka 22_5 = Wikisłownikarz | komórka 22_6 = Użytkownik | komórka 22_7 = Dyskusja wikisłownikarza | komórka 22_8 = Dyskusja użytkownika | komórka 23_1 = q | wiersze 23_1 = 2 | komórka 23_2 = Wikiquote | wiersze 23_2 = 2 | komórka 23_3 = pl | wiersze 23_3 = 2 | komórka 23_4 = Project | komórka 23_5 = Wikicytaty | komórka 23_6 = - | komórka 23_7 = Dyskusja Wikicytatów | komórka 23_8 = - | komórka 24_4 = User | komórka 24_5 = Użytkownik | komórka 24_6 = - | komórka 24_7 = Dyskusja użytkownika | komórka 24_8 = | komórka 25_1 = s | wiersze 25_1 = 2 | komórka 25_2 = Wikisource | wiersze 25_2 = 2 | komórka 25_3 = pl | wiersze 25_3 = 2 | komórka 25_4 = Project | komórka 25_5 = Wikiźródła | komórka 25_6 = - | komórka 25_7 = Dyskusja Wikiźródeł | komórka 25_8 = - | komórka 26_4 = User | komórka 26_5 = Wikiskryba | komórka 26_6 = Użytkownik | komórka 26_7 = Dyskusja wikiskryby | komórka 26_8 = Dyskusja użytkownika | komórka 27_1 = voy | wiersze 27_1 = 2 | komórka 27_2 = Wikivoyage | wiersze 27_2 = 2 | komórka 27_3 = pl | wiersze 27_3 = 2 | komórka 27_4 = Project | komórka 27_5 = Wikipodróże | komórka 27_6 = - | komórka 27_7 = Dyskusja Wikipodróży | komórka 27_8 = - | komórka 28_4 = User | komórka 28_5 = Użytkownik | komórka 28_6 = - | komórka 28_7 = Dyskusja użytkownika | komórka 28_8 = - | komórka 29_1 = n | wiersze 29_1 = 2 | komórka 29_2 = Wikinews | wiersze 29_2 = 2| komórka 29_3 = pl | wiersze 29_3 = 2 | komórka 29_4 = Project | komórka 29_5 = Wikinews | komórka 29_6 = - | komórka 29_7 = Dyskusja Wikinews | komórka 29_8 = - | komórka 30_4 = User | komórka 30_5 = Wikireporter | komórka 30_6 = Uzytkownik | komórka 30_7 = Dyskusja wikireportera | komórka 30_8 = Dyskusja użytkownika | komórka 31_1 = v | komórka 31_2 = Wikiversity | komórka 31_3 = - | kolumny 31_3 = 6 }} Tabela zawiera tylko ponadpodstawowe przestrzenie nazw z rożnych projektów, językowych lub nie, albo nie zawiera ich wcale, wtedy te przestrzeni są generowane na podstawie przy pomocy elementu tabeli {{Code|{{!(}}"wiki"{{)!}}}}, w tej tabeli jest to kolumna {{Code|Nazwa wiki}} - ta nazwa jest wykorzystana do tworzenia nazwy przestrzenie niekanonicznej przestrzeni nazw projektu. Przestrzenie podstawowe są takie same dla wszystkich projektów, tylko nazwy kanoniczne się nie zmieniają, a nazwy niekanoniczne są specyficzne dla danego języka projektu. Wersje językowe tych tabeli angielskich projektów zawierają tylko nazwy kanoniczne, które są tożsame z tymi niekanonicznymi. Ta tabela jest wykorzystywana przez szablon {{s|NpDane}} do tłumaczenia {{Code|id}} lub nazwy kanonicznej, na niekanoniczną, jeżeli istnieje, a jeżeli nie, to zamiast nazwy niekanonicznej wyświetlana jest nazwa kanoniczna. Można też tłumaczyć nazwę kanoniczną, czy niekanoniczną, na numer {{Code|id}}, ten numer jest uzyskiwany, dzięki szablonowi {{s|Np}}. Tak się dzieje, bo: {{s|NpDane}} i {{s|Np}}, mają względem siebie wspólne nazwy przestrzeni nazw kanoniczne o takich samych {{Code|id}}, ale o ogólnie innych nazwach niekanonicznych. Nazwy polskie, jako odpowiedni nazw angielskich różnych przestrzeni nazw, na innych projektach obcojęzycznych, można przetłumaczyć na polski względem tabelek powyżej, znając jedynie ich nazwy kanoniczne. Do tego celu używamy parametru {{Parametr|po polsku|tak}}. == Obsługiwane kody projektów lokalnych projektów siostrzanych {{NAZWASERWISU|link=tak|wikipedia=tak}} i ich pełne nazwy == {{Tabela|klasa=wikitable tekst-centruj-td|pozycja=prawo|liczba wierszy=14|liczba kolumn=2 | nagłówek 1 = kod projektu | nagłówek 2 = Pełna nazwa projektu | komórka 1_1 = w | komórka 1_2 = {{NAZWASERWISU|link=tak|klucz projektu=w}} | komórka 2_1 = b | komórka 2_2 = {{NAZWASERWISU|link=tak|klucz projektu=b}} | komórka 3_1 = wikt | komórka 3_2 = {{NAZWASERWISU|link=tak|klucz projektu=wikt}} | komórka 4_1 = q | komórka 4_2 = {{NAZWASERWISU|link=tak|klucz projektu=q}} | komórka 5_1 = s | komórka 5_2 = {{NAZWASERWISU|link=tak|klucz projektu=s}} | komórka 6_1 = voy | komórka 6_2 = {{NAZWASERWISU|link=tak|klucz projektu=voy}} | komórka 7_1 = n | komórka 7_2 = {{NAZWASERWISU|link=tak|klucz projektu=n}} | komórka 8_1 = v | komórka 8_2 = {{NAZWASERWISU|link=tak|klucz projektu=v}} | komórka 9_1 = commons | komórka 9_2 = {{NAZWASERWISU|link=tak|klucz projektu=commons}} | komórka 10_1 = wikispecies | komórka 10_2 = {{NAZWASERWISU|link=tak|klucz projektu=wikispecies}} | komórka 11_1 = d | komórka 11_2 = {{NAZWASERWISU|link=tak|klucz projektu=d}} | komórka 12_1 = mw | komórka 12_2 = {{NAZWASERWISU|link=tak|klucz projektu=mw}} | komórka 13_1 = m | komórka 13_2 = {{NAZWASERWISU|link=tak|klucz projektu=m}} | komórka 14_1 = wikimania | komórka 14_2 = {{NAZWASERWISU|link=tak|klucz projektu=wikimania}} }} Kody projektów przedstawiają kody projektów, jakie można włożyć do szablonu {{s|NpDane}}, czyli {{Parametr|kod projektu}}, nie wliczając: {{Parametr|kod jezyka}}, jak również do {{Parametr|klucz projektu}}, do którego można włożyć kombinację kodów języka i projektów, lub pojedynczy kod. Te kody natomiast nie można umieścić w szablonie {{s|Np}}, bo one tam się nie nadają, bo on tego nie używa. Szablon {{s|NAZWASERWISU|link{{=}}tak|kod jezyka{{=}}|kod projektu{{=}}|klucz projektu{{=}}}} (ale tutaj bez kodów języka, czy języków), użyty w tabelce, też zawiera te kody, użyty przy pomocy pary, lub pojedynczego parametru, przedstawia nazwy projektów wraz z referencjami do odpowiednich stron głównych. Strony ich główne sa ściągnięte za pomocą projektu: {{NAZWASERWISU|link=tak|klucz projektu=d}}, przy pomocy biblioteki i w niej funkcji: {{m|Wiki|WikidaneOdpowiednikStrony|nazwa strony{{=}}|kod języka{{=}}|kod projektu{{=}}|klucz projektu{{=}}|kod języka bazy{{=}}|kod projektu bazy{{=}}|klucz projektu bazy{{=}}}}. Zamiast: {{Parametr|klucz projektu}}, można użyć: {{Parametr|kod języka}} i {{Parametr|kod projektu}}, oraz odwrotnie, podobnie jest z ich wersjami dotyczące bazy. Nazwę strony: {{Parametr|nazwa strony}}, tłumaczonymi z projektu bazy przy pomocy kodów projektu i języka, na inny projekt operujący innymi kodami. W szczególnym przypadku możemy użyć tłumaczenia tożsamościowego. Tak właśnie działa właśnie ten szablon, o którym wspomnieliśmy. Strony w tym szablonie są tłumaczone przy pomocy, wychodząc od strony głównej: {{lr2|Strona główna}}, transformując je na inne projekty, tak je podawaliśmy w tej wspomnianej tabelce. Kody projektów, to nie jest to samo, co języka, projekty, to takie coś jak kod projektru {{NAZWASERWISU|klucz projektu=w|wikipedia=tak}}, a kod języka to przedstawia język, dzięki któremu poruzumiejemy się na pojekcie i w którym on jest właśnie pisany,jak {{Code|pl}} lub {{Code|en}}, ich użhywamy poprzez przedstawienie: {{Parametr|kod języka|en}} lub {{Parametr|klucz projektu|en:w}} (tutaj używamy wraz kodem projektu, lub bez niego w postaci: {{Parametr|klucz projektu|en}}, w tym pierwszy przenosimy się do angielskiej {{NAZWASERWISU|Wikipedii|link=tak|klucz projektu=en:w}}, albo w tym drugim przypadku do angielskiego: {{NAZWASERWISU|link=tak|po=a|klucz projektu=en:b}}. == Strony projektowe, użyte do tłumaczenia niektówych przestrzeni przedmiotowychna inne języki, z postaci kanonicznej (jako w nazwie angielskiej) do niekanonicznej (specyficznej dla projektu) == {{Tabela|klasa=wikitable tekst-centruj-td|pozycja=prawo|liczba wierszy=9|liczba kolumn=2 | nagłówek 1 = Nazwa kanoniczna | nagłówek 2 = Strona | komórka 1_1 = Project | komórka 1_2 ={{lr2|Administratorzy}} | komórka 2_1 = Help | komórka 2_2 = {{lp2|Spis treści}} | komórka 3_1 = Template | komórka 3_2 = {{ls2|Ek}} | komórka 4_1 = Module | komórka 4_2 = {{ld2|Wikidane}} | komórka 5_1 = Category | komórka 5_2 = {{lk2|Szablony}} | komórka 6_1 = Wikijunior | komórka 6_2 = {{lj2|Strona główna}} | komórka 7_1 = Portal | komórka 7_2 = {{lpt2|Matematyka}} | komórka 8_1 = Wikiproject | komórka 8_2 = {{lpw2|Matematyka}} | komórka 9_1 = Special | komórka 9_2 ={{lc2|Strony specjalne}} }} Nazwy projektowe, inne niż o nazwach kanonicznych: {{Np|Project|link=tak|nazwij projektem=tak|kanoniczna=tak}} i {{Np|Wikijunior|link=tak|kanoniczna=tak}}, są tłumaczone względem polskiej {{NAZWASERWISU|link=w|klucz projektu=w|Wikipedii}}, a pozostałe, względem polskiego {{NAZWASERWISU|link=tak}}. Tłumaczymy nazwy kanoniczne na niekanoniczne, specyficzne dla danego projektu. Można też tłumaczyć nazwy niekanoniczne z jednego języka na drugi, ale względem nazw kanonicznych. Do tłumaczenia nazw wykorzystujemy szablon {{s|NpDane}} (a nie {{s|Np}}). == Spis treści funkcji nazw == Oto jest spis treści w czterech częściach (tomach), przedstawiające różne funkcje w bibliotece (module {{lpg|Lua}} w {{lpr|Lua|Scribunto}}): * {{lr|Moduły/Nazwy/Tom I|Nazwy - Tom I}} - szablony: {{s|Np}}, {{s|NpDane}} i {{s|NAZWASERWISU}} i użyte do ich definicji funkcje biblioteczne, * {{lr|Moduły/Nazwy/Tom II|Nazwy - Tom II}} - szablony i procedury przestrzeni nazw i nazw stron, * {{lr|Moduły/Nazwy/Tom III|Nazwy - Tom III}} - wydzielanie z pełnej nazwy strony i liczenie różnych nazw z połączonych z mniejszych składowych, * {{lr|Moduły/Nazwy/Tom IV|Nazwy - Tom IV}} - szablony i funkcje: nazw książkowych stron i nazw przestrzeni tworów książkowych, oraz liczenie przy wykorzystywaniu tych konstrukcji, nazw sub- książki i strony, także nazwy stron korzeni (podstaw strony). Te części opisują różne funkcje wraz z parametrami, z przykładowymi użyciami w ich odpowiednikach szablonowych, które dodatkowo, w przeciwieństwie do funkcji bibliotecznych, mają walidacje błędów. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 5x6g8he3u4i7w4i1vwx78rihydql3i1 4 63231 541363 538765 2026-04-30T09:44:36Z Persino 2851 541363 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Ramka}}|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 ramka_modul=require("Module:Ramka"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. == {{Code|ParserBlokowy()}} == Funkcje się uruchamia w zwykłej funkcji w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}} tylko w module {{Code|{{ld2|Ramka}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function ParserBlokowy(frame, co_ma_wywolac)...end; </syntaxhighlight> Funkcja przyjmuje tablicę ramki tablicy transportu funkcji i drugi parametr, który mówi, czy ma uwzględniać dany szablon, jeżeli {{Tt|0}}, funkcję modułu, jeżeli {{Tt|1}}, i funkcję parsera, jeżeli: {{Tt|2}}, a {{Tt|3}} i dalej, to już dany szablon. Tablica ramki może przyjmować ze strony ramki dziecka szablonu, jak i parametry rodzica szablonu, te ramki są: * Funkcja przyjmuje parametry podstawowe, które piszemy w postaci: ** {{Code|Nazwa}} - jest to nazwa szablonu, modułu, czy parsera, ** {{Code|bez argumentów rodzica}} - tablica parametrów oddzielonych średnikami, których szablon nie przyjmuje,nawet jeżeli one są, ** {{Code|nazwa szablonu rodzica}} - jest to zmienna przechowująca nazwę szablonu rodzica ramki dziecka, ** {{Code|bez argumentów nienazwanych rodzica}} - szablon w ramce nie przyjmuje parametrów nienazwanych podanych w rodzicu ramki, ** {{Code|potomek}} - zmienna mówiąca, że to jest potomek rodzica ramki, jeżeli nie jest podany parametr {{Code|nie potomek}} - dodane przez tę funkcję, ** {{Code|nie potomek}} - zmienna mówiąca, że to nie jest potomek szablonu, ** {{Code|bez argumentów szablonu}} - zmienna oddzielonych średnikami parametrów, których nie wolno uwzględniać w walidacji błędów w {{m|Sprawdź|Parametry}}, ** {{Code|bez dodatkowych sprawdzeń}} - nie jest uruchamiana walidacja parametrów szablonu rodzica, ** {{Code|parametry rodzica}} - zmienna przedstawiająca parametry rodzica przekazane do ramki: {{m|Sprawdź|Parametry}} - dodane przez tę funkcję, ** {{Code|zmienna z parametrami rodzica}} - parametr mówiący, czy ma tworzyć zmienne z parametrami rodzica, a jeżeli nie jest on, z zadnych z jego potomków podany, to zmienna ta z parametrami jest przekazywana na kolejnego przodka, ** {{Code|zmienna z argumentami ramki}} - zmienna mówiąca, czy mają być tworzone parametry ramki,które nie są walidowane przez walidację błędów w {{m|Sprawdź|Parametry}}, wtedy te parametry rodzica nie mogą być podane, przy pomocy tej zmiennej zmienne z: {{Code|bez argumentów szablonu}} są łączone z parametrami ramki, ** {{Code|zmienna z nazwą szablonu rodzica}} - parametr, czy ma tworzyć zmienną: {{Code|nazwa szablonu rodzica}}, ** {{Code|parametry funkcji modułu pudełek}} - czy do funkcji mają wchodzić niepodstawowe nienazwane parametry modułu pudełek, a nie inne zmienne, ** {{Code|parametry podstawowe funkcji modułu pudełek}} - czy do funkcji mają wchodzić podstawowe parametry funkcji modułu pudełek, a nie inne zmienne, ** {{Code|usuń z parametrów ramki}} - parametr przedstawiający zmienne oddzielone średnikami, których parametrów ramki ma nie uwzględniać. * {{Code|Funkcja}} - nazwa funkcji w module, który ma wywołać, w przypadku, gdy parametr funkcji {{sr|#ParserBlokowy()|p=Ramka}} ma wartość {{Tt|1}}, czyli wywołujemy funkcję {{sr|#p["Moduł"]()|p=Ramka}}. Funkcja uruchamia szablon z parametrami rodzica ramki bez parametrów opisanych zmienną: {{Code|bez argumentów szablonu}}, i bez parametrów ramki minus zmienne opisane przez: {{Code|usuń z parametrów ramki}} dla wartości {{Tt|0}}, funkcję modułu ramki dla wartości {{Tt|1}}, funkcję parsera dla {{Tt|2}}, i {{Tt|3}} i dalej funkcję szablonu. Za pomocą tej funkcji możemy wielopoziomowo wywoływać funkcje przekazując parametry od najwyższego poziomu do najniższego. Ta funkcję jako do budowy szablonów, definiując też w jednym miejscu walidację błędów, dla przykładu wykorzystano ją w: {{s|Wzór}}, {{s|Wzór2}}, {{s|CentrujWzór}},{{s|CentrujWzór2}}, i inne, czyli uruchamianie szablonów, a uruchamianie funkcji modułu, w tym funkcji {{m|Cytuj|custom}} w szablonie {{s|PrzypisStrona}}. Przykładem wywołania szablonu jest, która jest w szablonie: {{s|Wzór}}, w którym jest wywoływany inny szablon, tym razem silnik tego szablonu: <syntaxhighlight lang="mediawiki"> {{#invoke:Ramka|Szablon|Nazwa=Wzór/silnik|pozycja numeracji=po prawej|wyrównanie={{{wyrównanie|lewy}}}|bez argumentów szablonu=pozycja numeracji|zmienna z parametrami rodzica=tak}} </syntaxhighlight> A przykład wywołania funkcji modułu, która jest w: {{s|PrzypisStrona}}, w którym jest wywoływany funkcja modułu {{m|Cytuj|custom}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Ramka|Moduł|Nazwa=Cytuj|Funkcja=custom | url = {{{adres}}}/{{{1|{{{podstrona}}}}}} | tytuł = {{{2|{{{nazwa}}}}}} | praca = {{lz | s = {{Jeśli niepuste|{{{serwis|}}}|{{Dopasuj|ciąg={{{adres}}}|wzór=^(%a+:%/%/[^%/]+)}}}} | n = {{Dopasuj|ciąg={{Jeśli niepuste|{{{serwis|}}}|{{{adres}}}}}|wzór=^%a+:%/%/([^%/]+)}} }} | data = {{#if:{{{data|}}}|{{Czas|Y-m-j|{{{data}}}}}}} | data dostępu = {{Czas|j.m.Y|{{{data dostępu|}}}}} }} </syntaxhighlight> == {{Code|BudowaSzereguZDanych()}} == Funkcje się uruchamia w zwykłej funkcji w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}} tylko w module {{Code|{{ld2|Ramka}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function BudowaSzereguZDanych(frame,tab_lancuch,minimum,maksimum)...end; </syntaxhighlight> Funkcja posiada następujące parametry podane w tablicy ramki dla funkcji zwracanej tablicy transportu: * {{Code|akapit}} - jeśli niepusta, to ona definiuje akapit ze znaków: {{Code|\n\n}}, * {{Code|przecinek}}- drukuje przecinek, jeśli posiada wartość niepustą, ten przecinek jest w postaci: {{Code|", "}}, został on specjalnie objęty w cudzysłowy, aby zilustrować, że po przzecinku znajduje się spacja, * {{Code|nowa linia}} - w przeciwieństwo do {{Code|akapit}}, pisze jedną nową linię, a nie dwie, jako: {{Code|\n}}, * {{Code|wyliczanka}} - wylicza elementy z przecinkami, stawiając przed ostatnim elementem zamiast jego wyraz wyliczania {{Code|i}}, * {{Code|początek}} - mówi, że na początku musi znajdować się przecinek, * {{Code|myślnik}} - mówi, że jeśli nie ma początku przecinka, to stawiany jest myślnik, używany zamiast {{Code|poczatek}}, * {{Code|warunkowe}} - instrukcje wikikodu niezawierające we wnętrzu klamerek zostaną rozwinięte, ** {{Code|parametr}} - mówi w derektywach, jeśli niepusty, że derektywy muszą przyjmować wartość w postaci pseudoszablonów, w przeciwnym wypadku jego odpowiednika znaku, ** Funkcja w tym warunku zwraca ciąg znaków rozwiniętego warunku. Funkcja posiada też mikroszablony: * {{Code|<nowiki>{{min}}</nowiki>}} - minimalna wartość szeregu zmiennych, * {{Code|<nowiki>{{max}}</nowiki>}} - a tutaj ich maksymalna. Te dwie zmienne są podstawiane do uzyskanego ciągu. Uzyskany tekst jest łączony za pomocą akapitu,a jak nie, to nowych linii, w przeciwnym wypadku jest łączony ciągiem pustym. Deklaracja, a zarazem definicja funkcji wygląda następująco: <syntaxhighlight lang="lua"> local function BudowaSzereguZDanych(frame,tab_lancuch,minimum,maksimum) ... end; </syntaxhighlight> * {{Code|frame}} - tablica ramki w tablica transportu funkcji {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, * {{Code|tab_lancuch}} - jest to tablica uzyskanych z innych funkcji wikikodów w tym module, * {{Code|minimum}} - jak powyżej: {{Code|<nowiki>{{min}}</nowiki>}}, * {{Code|maksimum}} - jak powyżej: {{Code|<nowiki>{{max}}</nowiki>}}. Funkcja zwraca rozwinięty, co do instrukcji warunkowych bez wewnętrznych klamerek, połączonych podanych łańcuchów odpowiednio w postaci tablicy, do odpowiedniego szeregu, pod którym jest ukryty wikikod. == {{Code|p.InstrukcjeWarunkowe()}} == Funkcje się uruchamia w zwykłej funkcji w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. {{Tabela|klasa=wikitable tekst-centruj-td|pozycja=prawo|liczba wierszy=12|liczba kolumn=3 | nagłówek 1 = Derektywa | nagłówek 2 = Odpowiednik znakowych | nagłówek 3 = Pseudoszablon | komórka 1_1 = __!__ | komórka 1_2 = &#124; | komórka 1_3 = {{s|!}} | komórka 2_1 = __!!__ | komórka 2_2 = &#124;&#124; | komórka 2_3 = {{s|!!}} | komórka 3_1 = __(__ | komórka 3_2 = &#123; | komórka 3_3 = {{s|(}} | komórka 4_1 = __((__ | komórka 4_2 = &#123;&#123; | komórka 4_3 = {{s|((}} | komórka 5_1 = __(((__ | komórka 5_2 = &#123;&#123;&#123; | komórka 5_3 = {{s|(((}} | komórka 6_1 = __)__ | komórka 6_2 = &#125; | komórka 6_3 = {{s|)}} | komórka 7_1 = __))__ | komórka 7_2 = &#125;&#125; | komórka 7_3 = {{s|))}} | komórka 8_1 = __)))__ | komórka 8_2 = &#125;&#125;&#125; | komórka 8_3 = {{s|)))}} | komórka 9_1 = __!(__ | komórka 9_2 = &#91; | komórka 9_3 = {{s|!(}} | komórka 10_1 = __!((__ | komórka 10_2 = &#91;&#91; | komórka 10_3 = {{s|!((}} | komórka 11_1 = __)!__ | komórka 11_2 = &#93; | komórka 11_3 = {{s|)!}} | komórka 12_1 = __))!__ | komórka 12_2 = &#93;&#93; | komórka 12_3 = {{s|))!}} }} Definicja częściowa tego kodu jest w postaci: <syntaxhighlight lang="lua"> p.InstrukcjeWarunkowe = function(ciag,derektywy_specjalne,derektywy_parametrowe)...end; </syntaxhighlight> * {{Code|ciag}} - podany ciąg do rozwinięcia z instrukcji warunkowych wewnątrz nie posiadający klamewrek, * {{Code|derektywy_specjalne}} - używa do zastępowania specjalnych derektyw, podane poniżej, * {{Code|derektywy_parametrowe}} - czy używać pseudoszablonów zamiast ich odpowiedników znakowych. Obsługiwane instrukcje warunkowe: {{Code|{{s|#if:[^{}]*}}}}, {{Code|{{s|#ifeq:[^{}]*}}}}, {{Code|{{s|#switch:[^{}]*}}}}, {{Code|{{s|#ifexpr:[^{}]*}}}}, {{Code|{{s|#expr:[^{}]*}}}}, {{Code|{{s|#iferror:[^{}]*}}}} i {{Code|{{s|#iferror:[^{}]*}}}}. Ta funkcja jest używana przez funkcję: {{Code|{{sr|#BudowaSzereguZDanych()|p=Ramka}}}}, poprzez funkcję: {{Code|{{sr|#p.Powtarzaj()|p=Ramka}}}}. Przykłady użycia pośrednio przez tą ostatnią funkcję: ona jest użyta w walidacji błędów {{m|Sprawdź|Parametry}} poprzez: {{m|Ramka|Powtarzaj|...|warunkowe{{=}}tak|...}}, na przykładzie w kodzie derektywy: {{Code|__!__}}. == {{Code|p.RozpakujArgumenty()}} == Funkcje się uruchamia w zwykłej funkcji w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.RozpakujArgumenty = function(zmienna_z_argumentami)...end; </syntaxhighlight> Funkcja przyjmuje jeden parametr ze zmiennymi oddzielonych średnikami, je rozpakowuje wyjmując z pól pomiędzy średnikami zmienne, i układa je w tablicy, która jest zwaracana jako parametr, te parametry mogą mięć mikroszablony, które sa zastępowane odpowiednikami znakowymi. Jedynym tego przykładem jest mikrofunkcja {{Code|<nowiki>{{+}}</nowiki>}}, ktora jest zamieniana na średnik. == {{Code|p.PakujParametry()}} == Funkcje się uruchamia w zwykłej funkcji w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja pakuje parametry tablicy {{lpg|Lua}} do tablicy: {{Code|JSON}}, przy pomocy funkcji, którego wynik jest zwracany do tej funkcji: <syntaxhighlight lang="lua"> p.PakujParametry = function(args) return mw.text.jsonEncode(args,mw.text.JSON_PRESERVE_KEYS); end; </syntaxhighlight> Ten szablon nazywa parametry jakby nienazwane w tablicy {{Code|JSON}} (tutaj numerowanie jest od zera) z tablicy {{lpg|Lua}} (tutaj od jedynki), do tablicy nazwanej, jak to robi się w {{Lpr|Lua|Scribunto}}. == {{Code|p.RozpakujParametry()}} == Funkcje się uruchamia w zwykłej funkcji w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja rozpakowuje parametry z tablicy: {{Code|JSON}}, do tablicy {{lpg|Lua}}, przy pomocy funkcji, którego wynik jest zwracany do tej funkcji: <syntaxhighlight lang="lua"> p.RozpakujParametry = function (zmienna_z_parametrami) return mw.text.jsonDecode(args,mw.text.JSON_PRESERVE_KEYS); end; </syntaxhighlight> Ten szablon nazywa parametry nienazwane w tablicy {{lpg|Lua}} (tutaj od jedynki) z tablicy {{Code|JSON}} (tutaj numerowanie jest od zera), do tablicy nienazwanej z nazwanej, jak to robi się w {{Lpr|Lua|Scribunto}}. == {{Code|p["Rozwiń"](frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Rozwiń"] = function(frame)...end; </syntaxhighlight> Szablon rozwija wikikod podany w zmiennej {{Code|1}}. * Szablon jest użyty w szablonie: {{s|Wybrane grupy książek}}, która generuje układ wielokolumnowy układ bloków ramkowych przy pomocy funkcji: {{s|Blok ramkowy}} i {{s|Blok ramkowy/Zamknij}}, * Szablon również jest użyty w szablonach: {{s|Osobny artykuł/silnik}}, {{s|Kategoria główna/silnik}}, {{s|Spójrz też/silnik}}, itd.. Przykład wywołania funkcji: * {{Code|{{m|Ramka|Rozwiń|1{{=}}<wikikod>}}}} - funkcja rozwija podany wikikod podany w zmiennej {{Code|1}}. Kod tej funkcji bibliotecznej w tym module, tzn.: {{Ld2|Ramka}}, jest: <syntaxhighlight lang="lua"> p["Rozwiń"] = function(frame) return frame:getParent():preprocess(frame.args[1]); end; </syntaxhighlight> == {{Code|p.Log(frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.Log = function(frame)...end; </syntaxhighlight> Szablon wysyła logi do konsoli {{Code|MediaWiki}} w postaci tekstu: ukryty pod zmienna: {{Code|log}}, i ewentualnie zwraca ten tekst, jeżeli zmienna: {{Code|wikitext}}, przyjmuje wartość niepustą, lub jest niepodana. Przykłady użycia funkcji: * {{Code|{{m|Ramka|Log|log{{=}}<tekst>|wikitext{{=}}tak}}}}- tutaj funkcja (ramka) wysyła do konsoli tekst ukryty pod zmienną: {{Parametr|log|<tekst>}}, i jednocześnie zwraca jej wartość. Kod tej funkcji bibliotecznej w tym module, tzn.: {{Ld2|Ramka}}, jest: <syntaxhighlight lang="lua"> p.Log = function(frame) local parametry_modul=require("Module:Parametry"); local czy_zwracac=parametry_modul.CzyTak(frame.args["wikitext"]); local wikitekst=frame.args["log"]; mw.log(wikitekst); return (czy_zwracac and wikitekst or ""); end; </syntaxhighlight> == {{Code|p.Szablon(frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Funkcja wywołuje inną funkcję, ale lokalną w postaci zwracanej wartości dla drugiego parametru zerowego {{Code|0}} symbolizującego rozwijanie szablonu: <syntaxhighlight lang="lua"> p.Szablon = function(frame) return ParserBlokowy(frame,0); end; </syntaxhighlight> Szablon przyjmuje te same parametry tablicy ramki {{Code|frame}}, co: {{Code|ParserBlokowy}}. == {{Code|p["Moduł"](frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Funkcja wywołuje inną funkcję, ale lokalną w postaci zwracanej wartości dla drugiego parametru zerowego {{Code|1}} symbolizującego rozwijanie funkcji modułu ramki: <syntaxhighlight lang="lua"> p["Moduł"] = function(frame) return ParserBlokowy(frame,1); end; </syntaxhighlight> Szablon przyjmuje te same parametry tablicy ramki {{Code|frame}}, co: {{Code|ParserBlokowy}}. == {{Code|p.Parser(frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Funkcja wywołuje inną funkcję, ale lokalną w postaci zwracanej wartości dla drugiego parametru zerowego {{Code|2}} symbolizującego rozwijanie funkcji parsera: <syntaxhighlight lang="lua"> p.Parser = function(frame) return ParserBlokowy(frame,2); end; </syntaxhighlight> Szablon przyjmuje te same parametry tablicy ramki {{Code|frame}}, co: {{Code|ParserBlokowy}}. == {{Code|p.Q(frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.Q =function(frame)...end; </syntaxhighlight> Szablon {{s|Q}} przyjmuje tylko jeden parametr {{Parametr|1}}, którą jest nazwa niepełna szablonu, modułu, czy kategorii. Szablon {{s|T}} podobnie jak poprzedni szablon, tylko dodatkowo dopuszcza parametry szablonu, którego uruchamia z nimi szablon (funkcja) o nazwie uzyskanej z funkcji {{m|Ramka|N}}. Szablon {{s|Q}} parametry nienazwane większe od jeden, ale nie pierwszy parametr, jego numer zmniejsza o jeden, a inne pozostawia je w takiej formie, jakim są (nie pierwszy, który nie jest wliczany do parametrów szablonu). W ten sposób wywołujemy szablon podany jako pierwszy parametr tego szablonu z tymi tak uzyskanymi parametrami. === Przykłady użycia funkcji {{s|Ramka|Q}}, a zarazem szablonu {{s|Q}} === * {{Code|{{s|Q|Unicode-c|wstecz{{=}}13|dalej{{=}}15}}}} → {{OverflowWiersz|{{T|Unicode-c|wstecz=13|dalej=15}}}} == {{Code|p.N(frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.N=function(frame)...end; </syntaxhighlight> Szablon {{s|N}}, a zarazem funkcja {{s|Ramka|N}} ze strony parametrów ramki, przyjmuje tylko jeden parametr {{Parametr|1}}, którą jest nazwa niepełna szablonu, modułu, czy kategorii. Szablon {{Code|{{s|N|<nazwa strony>|p{{=}}{{!(}}0{{!}}1{{!}}2{{)!}}|n{{=}}tak}}}} przyjmuje parametry oznaczające: * {{Code|p}}, tzn. {{Parametr|p|0}} lub niepodana, oznacza przestrzeń szablonu, {{Parametr|p|1}} przestrzeń modułu i {{Parametr|p|2}} przestrzeń kategorii. * {{Code|n}}, gdy pusta lub niepodana oznacza pełną nazwę strony, a gdy jest niepusta, tylko nazwę strony. === Przykłady użycia funkcji {{m|Ramka|N}} i szablonu {{s|N}} === * {{Code|{{s|N|Unicode-c}}}} → {{Code|{{N|Unicode-c}}}}, {{Code|{{s|N|Unicode-c|n{{=}}tak}}}} → {{Code|{{N|Unicode-c|n=tak}}}} * {{Code|{{s|N|Unicode-c|p{{=}}0}}}} → {{Code|{{N|Unicode-c|p=0}}}}, {{Code|{{s|N|Unicode-c|p{{=}}0|n{{=}}tak}}}} → {{Code|{{N|Unicode-c|p=0|n=tak}}}} * {{Code|{{s|N|Zbiór zadań maturalnych|p{{=}}1}}}} → {{Code|{{N|Zbiór zadań maturalnych|p=1}}}}, {{Code|{{s|N|Zbiór zadań maturalnych|p{{=}}1|n{{=}}tak}}}} → {{Code|{{N|Zbiór zadań maturalnych|p=1|n=tak}}}} * {{Code|{{s|N|Zbiór zadań maturalnych/Szablony|p{{=}}2}}}} → {{Code|{{N|Zbiór zadań maturalnych/Szablony|p=2}}}}, {{Code|{{s|N|Zbiór zadań maturalnych/Szablony|p{{=}}2|n{{=}}tak}}}} → {{Code|{{N|Zbiór zadań maturalnych/Szablony|p=2|n=tak}}}} == {{Code|p.A(frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.A=function(frame)...end; </syntaxhighlight> Szablon {{s|A}}, a zarazem funkcja: {{m|Ramka|A}}, z nazwy szablony (bez przestrzeni nazw) usuwa przedrostek {{Code|Książka:}}. Szablon {{Code|{{s|Q|<nazwa strony>|p{{=}}{{!(}}0{{!}}1{{!}}2{{)!}}}}}} przyjmuje parametry oznaczające: * {{Code|p}}, gdy pusta lub niepodana oznacza pełną nazwę strony, a gdy jest niepusta, tylko nazwę strony. === Przykład wykorzystania szablonu {{s|A}}, a zarazem funkcji funkcji {{m|Ramka|A}} === * {{Code|{{s|A|{{N|Unicode-c|n=tak}}}}}} → {{Code|{{A|{{N|Unicode-c|n=tak}}}}}}, {{Code|{{s|A|{{N|Unicode-c}}|p{{=}}tak}}}} → {{Code|{{A|{{N|Unicode-c}}|p=tak}}}} == {{Code|p.Powtarzaj(frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.Powtarzaj = function(frame)...end; </syntaxhighlight> Funkcja może przyjmować tylko parametry nienazwane, tylko nazwane, lub nienazwane i nazwane. Funkcja jako podany parametr pierwszy: <syntaxhighlight lang="mediawiki"> {{#invoke:Ramka|Powtarzaj|1=<wikikod>}} </syntaxhighlight> iteruje po podanych parametrach, jako parametry szablonu w zależności od parametrów ramki, zastępując pewne wielkości. Te wielkości to: * {{Code|{{((}}_{{))}}}} (w nawiasach klamrowych podwójnych jest jeden dolny myślnik) - parametr numerowany przyjmujący wartość numerowaną od więcej od {{Code|1}} lub {{Code|1}}, * {{Code|{{((}}__{{))}}}} (w nawiasach klamrowych podwójnych są dwa dolne myślniki) - parametr numerowany przyjmujący wartość numerowaną od więcej od {{Code|1}} albo {{Code|1}} lub ciąg pusty (wtedy tutaj dla jedynki, jeżeli zmienna: {{Code|<zmienna> 1}} lub {{Code|<zmienna>1}}, istnieje, a teraz dla ciągu pustego, jeżeli zmienna {{Code|<zmienna>}} istnieje), one są podane w zmiennych parametrach szablonach, jeżeli w nich wywołana jest ta ramka wywołującą tę funkcję. Parametrem określającym, że brane są pod lupę parametry nazwane i nienazwane, jest zmienna {{Code|różne}}, która wtedy ma wskazywać na wartość niepustą. Najważniejsze parametry, które są to opcjonalne, to są: * {{Code|start}} - liczba, która wskazuje początek liczenia - domyślna wartość to {{Code|1}}, * {{Code|koniec}} - liczba, która wskazuje koniec liczenia. Elementy w {{Code|parametry}} mogą modyfikować odpowiednio te parametry podane zaraz powyżej, ale najpierw parametr wskazujący koniec liczenia musi być policzony w pierwszej fazie, a jeżeli nie ma parametrów nazwanych, wtedy liczy się maksimum numeracyjne parametrów numerowanych, a jeżeli są nazwane, a jeżeli {{Code|różne}} nie jest niepuste, to się liczy maksimum parametrów nazwanych, a w przeciwnym wypadku mamy w zależności od parametru: {{Code|maksimum numeracyjne}}, jeżeli niepusty, to liczy się maksimum numeracyjne, w przeciwnie maksimum z maksimum numeracyjnego i parametrów nazwanych (który zależy od parametru przesunięcia dla danego parametru i parametrów ogólnie, wspólny dla wszystkich parametrów - wyjaśnienie poniżej). To maksimum parametrów nazwanych, dla jakieś podstawy parametrów, jest pomijane, gdy {{Code|dodatkowe}}, która jest zestawem podstaw parametrów oddzielonych średnikami, jest właśnie podany ten parametr w nim. Przykładem jego jest: {{Pre|{{Parametr|dodatkowe|<zmienna 1>;<zmienna 2>;<zmienna 3>}}}} Gdzie zamiast zmiennych {{Code|<zmienna 1>,...}} są pewne nazwy baz parametrów nazwowych bez numerka na samym końcu i ewentualnie spacji. Funkcja przyjmuje ważny parametr {{Code|parametry}} dla parametrów specjalnie nazwanych. Elementy w nim są oddzielone średnikami dla każdej zmiennej z osobna, a dla danej zmiennej zmienne są przedzielone przecinkami. Na początku tego jest opcjonalny element naturalny wspólny dla wszystkich zmiennych oddzielonych od pozostałych elementów średnikiem, jeżeli istnieją. Nie licząc wspólnego elementu dla wszystkich parametrów, to dla danej zmiennej liczba maksymalna elementów podanych po kolei jest {{Code|5}}. Dla danej zmiennej elementy oddzielone przecinkami piszemy w formie: * element pierwszy, to jest parametr, jeżeli niepusty, określający, że pomiędzy podstawą elementu, a liczbą, ma być zero spacji, * element drugi, to jest parametr, jeżeli niepusty, określający, że dla pierwszego elementu ma pisać jedynkę zamiast jedynki lub wartości pustej w zależności od istnienia takiej pierwszej zmiennej, * element trzeci, to jest parametr, jest to liczba przesunięcia, od której ma liczyć parametr nazwany, * element czwarty, to jest parametr określający, od jakiej liczby ma zaczynać na początku od dodatniego wskaźnika (zmiennej), brana jest liczba minimalna dodatnia, ze wszystkich takich liczb, uwzględniając element, od którego startuje liczenie, * element piąty, to jest parametr określający, do jakiej liczby ma kończyć iterację dla danego wskaźnika (zmiennej), jako koniec liczenia brana jest liczba maksymalna dodatnia, ze wszystkich takich liczb, uwzględniając na początku policzony powyżej koniec liczenia. Przykładem tego parametru dla danej zmiennej jest: {{Code|tak,tak,5,3,4}}, a z dodatkiem globalnego przesunięcia dla wszystkich zmiennych: {{Parametr|parametry|5;<zmienna>{{=}}tak,tak,5,3,4}}, a dla wielu zmiennych: {{Pre|{{Parametr|parametry|5;<zmienna 1>{{=}}tak,tak,5,3,4;<zmienna 2>{{=}}tak,,10,7,9;<zmienna 3>{{=}},tak,8,9,11}}}} Zamiast wartości: {{Code|zmienna 1>}}, {{Code|<zmienna 2>}} i {{Code|<zmienna 3>}}, są pewne nazwy bazowe parametrów bez numerka na jej końcu. W zmiennej {{Code|parametry}} można nie podawać dalsze elementy po przecinku, jeżeli są puste lub nieważne (nic nie zmieniają) lub można nie podać nic po znaku {{Code|{{=}}}} (a w tym przypadku nawet można nie podawać tego znaku) dla danego problemu funkcji. Parametrem {{Parametr|1|<wikikod>}},którego wartość, jest wikikodem do iteracji, gdy ten parametr nie jest podany, to funkcja zwraca wartość {{Code|(brak parametru do analizy)}}, a gdy ten parametr jednak jest podany, ale jest ciągiem pustym, wtedy wartość zwracana jest {{Code|(parametr do analizy pusty)}}. Gdy parametr {{Code|tonumber(frame.args["start"]) or 1}}, jest równy zero, funkcja zwraca błąd: {{Code|(początek jest ustawiony na zero)}}. A jeżeli zatem żaden parametr nie jest podany, to można użyć argumentu {{Code|niepodane}}, która wygeneruje jeden krok, tylko jeden, iteracji. Gdy {{Code|nic}} przyjmuje wartość, i gdy pomijamy parametr, lub on przyjmuje wartość pustą, wtedy a funkcja nie może generować żadnego kroku iteracji, to wtedy jest zwracana wartość niepusta {{Code|nic}} lub ciąg pusty. Parametr {{Code|po kolei}} niepusty powoduje, że zbieranie parametrów odbywa się od pewnego miejsca i idzie w sposób ciągły do góry, co jeden, aż do pewnej granicy. Parametr {{Code|wytnij}} wycina parametry puste i niepodane, a {{Code|wytnij puste}} tylko puste, ale {{Code|nie wytnij nazwane}} nie wycina parametrów nazwanych. Znacznik {{Code|_i}} określa symbol, jak ona może być używana do zastępowania zmiennych typu {{Code|<nowiki>{{((}}_i{{))}}</nowiki>}} i {{Code|<nowiki>{{((}}_i_i{{))}}</nowiki>}}, wtedy ich się używa zamiast: {{Code|<nowiki>{{((}}_{{))}}</nowiki>}} i {{Code|<nowiki>{{((}}__{{))}}</nowiki>}}. W wyniku iteracji otrzymamy tablicę ciągów łańcuchów z wiikodami, wtedy ta funkcja używa funkcji: {{Pre|lancuch_znakow {{=}} BudowaSzereguZDanych(frame,tab_lancuch,minimum or 0,maksimum);}} wraz z jego parametrami podane w jego ramce {{Code|frame}}, które jednocześnie sa parametrami {{m|Ramka|Powtarzaj}}, używa do łączenia w pewien określony zbiór uporządkowanych ciągów do jednego łańcucha, który jest zwracany bezpośrednio przez tę funkcję bez rozwijania przy parametrze {{Parametr|nie rozwiń|tak}}, a gdy on nie przyjmuje wartości niepustej, w takim razie on jest rozwijany funkcją {{Code|pf:preprocess(lancuch_znakow)}}, i jest zwracany jako wartość omawianej funkcji. Funkcja jest używana np. w silnikach szablonów, np.: {{s|Osobny artykuł/silnik}} szablonu {{s|Osobny artykuł}}, jak i jego podobnych szablonów, wykorzystujących ten właśnie silnik. Również przykładem jest: {{s|Kategoria główna/silnik}} szablonu {{s|Kategoria główna}} i innych, którego jest on silnikiem. A nawet podobnie jest z: {{s|Spójrz też/silnik}} szablonu {{s|Spójrz też}}. Podobnie się definiuje inny szablon, który drukuje nierozwinięty wikikod ze składników przy pomocy parametrów, który po włączeniu do większego kodu, dopiero wtedy jest rozwijany, przykładem tego jest: {{s|Wybrane grupy książek}}. == {{Code|p.PowtarzajOdDo(frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.PowtarzajOdDo=function(frame)...end; </syntaxhighlight> Funkcja tworzy wikikod do rozwinięcia, np. przez funkcję {{m|Ramka|Rozwiń}}, lub go rozwija na końcu, na podstawie kolejnych kroków iteracji: * {{Code|start}} - początek iteracji dokonywany przez ta funkcję, * {{Code|koniec}} - koniec iteracji dokonywany przez ta funkcję, * {{Code|krok}} - krok iteracji, co którynumer ma iterować, * {{Code|łącznik}} - szereg łączących elementy z wikikodem, a jak nie ma tego elementu podanego, to czy ma być oddzielony nową linią na podstawie zmiennej {{Code|nowa linia}}, a jeżeli to nawet nie jest podane, to podany ciąg jest łączony poprzez szereg pusty, * {{Code|nowa linia}} - szereg mówiący, czy ma łączyć szeregi kodem nową linią, jeżeli {{Code|łącznik}} nie jest podany, * {{Code|przeskok}} - dodatkowy krok, nie licząc jedynki, jak ma iterować ciąg, ** Ta zmienna w każdym kroku iteracji zależna jest od: {{Code|<nowiki>{{_}}</nowiki>}} i {{Code|<nowiki>{{ciąg}}</nowiki>}}, mówiąca o numerze jego kroku, * {{Code|nie rozwiń}} - niepusta wartość, wtedy kod nie jest rozwijany, jeśli uzyskany kod nie jest rozwijany, w końcowym etapie można go rozwinąć przy pomocy funkcji {{m|Ramka|Rozwiń}}, * {{Code|1}} - aktualny wikikod ze zmiennymi poniżej przedstawiający aktualny krok iteracji, z którego dla każdego elementu te ciągi są łaczone za pomocą łącznika. Zmienne w kodzie: {{Code|1}} i {{Code|przeskok}} (jeżeli podana), podstawiane w nich pewne zmienne, które zamiast nich pewne liczby coś symbolizujące: * {{Code|<nowiki>{{start}}</nowiki>}} - przyjmuje wartość {{Tt|1}}, * {{Code|<nowiki>{{koniec}}</nowiki>}} - przyjmuje wartość, który jest liczbą elementów w ciągu oddzielonych średnikami w zmiennej {{Code|ciąg}}, * {{Code|<nowiki>{{krok}}</nowiki>}} - przyjmuje wartość {{Tt|1}}. Zmienne inne za każdym krokiem iteracji, z których korzystają: {{Code|1}} i {{Code|przeskok}}: * {{Code|<nowiki>{{_}}</nowiki>}} - symbol, za którą jest podstawiana liczba przyjmująca aktualną wartość numeru iteracji. Przykładowym kodem jest kod, którego wikikod znajduje się szablonu w silniku: {{s|Chem/silnik}}, szablonu: {{s|Chem}}, przykłady działania tego kodu: * {{Code|{{s|Chem|C|n|H|2n&nbsp;+&nbsp;2}}}} → {{Tt|{{Chem|C|n|H|2n&nbsp;+&nbsp;2}}}} * {{Code|{{s|Chem|H|3|O|+}}}} → {{Tt|{{Chem|H|3|O|+}}}} * {{Code|{{s|Chem|SO|4|2-}}}} → {{Tt|{{Chem|SO|4|2-}}}} * {{Code|{{s|Chem|4|He}}}} → {{Tt|{{Chem|4|He}}}} * {{Code|{{s|Chem|4|2|He}}}} → {{Tt|{{Chem|4|2|He}}}} Na podstawie tej funkcji dokonano w szablonie {{s|Chem}}, że ona może przyjmować dowolną liczbę parametrów numerowanych. == {{Code|p["PrzetwarzajIterującCiąg"](frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["PrzetwarzajIterującCiąg"]=function(frame)...end; </syntaxhighlight> Funkcja do iteracji ciągu z wikikodem i pewnymi zmiennymi. * {{Code|ciąg}} - lista parametrów oddzielonych średnikami, z którego jest tworzona tablica z elementów pomiędzy srednikami, * {{Code|łącznik}} - szereg łączących elementy z wikikodem, a jak nie ma tego elementu podanego, to czy ma być oddzielony nową linią na podstawie zmiennej {{Code|nowa linia}}, a jeżeli to nawet nie jest podane, to podany ciąg jest łączony poprzez szereg pusty, * {{Code|nowa linia}} - szereg mówiący, czy ma łączyć szeregi kodem nową linią, jeżeli {{Code|łącznik}} nie jest podany, * {{Code|przeskok}} - dodatkowy krok, nie licząc jedynki, jak ma iterować ciąg, ** Ta zmienna w każdym kroku iteracji zależna jest od: {{Code|<nowiki>{{_}}</nowiki>}} i {{Code|<nowiki>{{ciąg}}</nowiki>}}, mówiąca o numerze jego kroku, * {{Code|nie rozwiń}} - niepusta wartość, wtedy kod nie jest rozwijany, jeśli uzyskany kod nie jest rozwijany, w końcowym etapie można go rozwinąć przy pomocy funkcji {{m|Ramka|Rozwiń}}, * {{Code|1}} - aktualny wikikod ze zmiennymi poniżej przedstawiający aktualny krok iteracji, z którego dla każdego elementu te ciągi są łaczone za pomocą łącznika. Zmienne w kodzie: {{Code|1}} i {{Code|przeskok}} (jeżeli podana), podstawiane w nich pewne zmienne, które zamiast nich pewne liczby coś symbolizujące: * {{Code|<nowiki>{{start}}</nowiki>}} - przyjmuje wartość {{Tt|1}}, * {{Code|<nowiki>{{koniec}}</nowiki>}} - przyjmuje wartość, który jest liczbą elementów w ciągu oddzielonych średnikami w zmiennej {{Code|ciąg}}, * {{Code|<nowiki>{{krok}}</nowiki>}} - przyjmuje wartość {{Tt|1}}. Zmienne inne za każdym krokiem iteracji, z których korzystają: {{Code|1}} i {{Code|przeskok}}: * {{Code|<nowiki>{{_}}</nowiki>}} - symbol, za którą jest podstawiana liczba przyjmująca aktualną wartość numeru iteracji, * {{Code|<nowiki>{{ciąg}}</nowiki>}} - jest to wartość pojedynczego elementu w {{Code|ciąg}}. Przykładowym kodem jest kod, którego część znajduje się tutaj, z szablonu {{s|Status}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Ramka|PrzetwarzajIterującCiąg | ciąg = {{{junior}}} | przeskok = 0 | 1 = {{((}}#if:{{((}}ciąg{{))}} {{!}}{{((}}#invoke:Ramka{{!}}Szablon {{!}}parametry funkcji modułu pudełek{{=}}tak {{!}}Nazwa{{=}}Kategoria{{!}}Wikijunior:{{((}}ucfirst:{{((}}ciąg{{))}}{{))}} {{))}} {{))}} }} </syntaxhighlight> Wartością w tym przypadku zmiennej szablonowej {{Code|<nowiki>{{{junior}}}</nowiki>}} może być: {{Parametr|junior|Owoce;Warzywa}}. Ta funkcja najpierw iteruje po wartości {{Code|Owoce}}, a później po {{Code|Warzywa}}. Powyższy kod, uzyskany w ten sposób wikikod, jest rozwijany za pomocą funkcji systemowej {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: {{Code|pf:preprocess(lancuch)}}, jeśli: {{Code|nie rozwiń}}, nie przybiera wartości niepustej. == {{Code|p["PowtarzajWedług"](frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["PowtarzajWedług"] = function(frame)...end; </syntaxhighlight> Funkcja wyszukuje ile jest stron o danym wzorze, np.dla stron o podstawie „{{Ns:Template}}:Polecane książki/”:{{Parametr|wzór|{{Ns:Template}}:Polecane książki/{{((}}_{{))}}}}. * {{Code|start}} - od jakiej liczby ma liczyć strony (domyślną wartością jest {{Code|1}}, od której zaczyna się liczenie stron o podany wzorze numeracyjnym), * {{Code|wzór}} - wzór według tego, co ma sprawdzając, czy one pasują do niego. Parametr {{Code|wzór}} ma w sobie {{font|color=blue|<nowiki>{{_}}</nowiki>}}, za którą podstawiany jest numer w postaci liczby naturalnej innej niż zero. === Przykłady użycia === Przykład z tą funkcją znajduje się w kodzie w szablonie: {{s|Lista wybranych książek}}, która po wywołaniu wypluwa wynik: * Szablon wypluwający listę stron według wzoru w postaci tekstu: ** {{Code|{{s|Lista wybranych książek|Polecane książki}}}} → {{Tt|{{Lista wybranych książek|Polecane książki}}}} ** {{Code|{{s|Lista wybranych książek|Nowe podręczniki miesiąca}}}} → {{Tt|{{Lista wybranych książek|Nowe podręczniki miesiąca}}}} ** {{Code|{{s|Lista wybranych książek|Wyróżnienia książek miesiąca}}}} → {{Tt|{{Lista wybranych książek|Wyróżnienia książek miesiąca}}}} * Szablon wypluwający listę stron według wzoru w postaci linków: ** {{Code|{{s|Lista wybranych książek|Polecane książki|link{{=}}tak}}}} → {{Tt|{{Lista wybranych książek|Polecane książki|link=tak}}}} ** {{Code|{{s|Lista wybranych książek|Nowe podręczniki miesiąca|link{{=}}tak}}}} → {{Tt|{{Lista wybranych książek|Nowe podręczniki miesiąca|link=tak}}}} ** {{Code|{{s|Lista wybranych książek|Wyróżnienia książek miesiąca|link{{=}}tak}}}} → {{Tt|{{Lista wybranych książek|Wyróżnienia książek miesiąca|link=tak}}}} == {{Code|p["LiczbaPrawychUkośników"](frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaPrawychUkośników"] = function(frame)...end; </syntaxhighlight> Szablon wyszukuje liczbę prawych ukośników w wielopoziomowym adresie strony. * {{Code|1}} - wielopoziomowy adres z ewentualnie prawymi ukośnikami. Jeżeli ten adres nie zawiera tych ukośników, to funkcja zwraca wartość {{Tt|0}}. === Przykład użycia === * {{Code|{{m|Ramka|LiczbaPrawychUkośników|1{{=}}Podstawia/Poziom_1/Poziom_2/Poziom_3/Poziom_4/Poziom_5}}}} → {{Tt|{{#invoke:Ramka|LiczbaPrawychUkośników|1=Podstawia/Poziom_1/Poziom_2/Poziom_3/Poziom_4/Poziom_5}}}} == {{Code|p["MaksymalnaLiczbaNumerowanychIstniejącychStronWedługWzoru"](frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["MaksymalnaLiczbaNumerowanychIstniejącychStronWedługWzoru"] = function(frame)...end; </syntaxhighlight> Funkcja wyszukuje ile jest stron o danym wzorze, np.dla stron o podstawie „{{Ns:Template}}:Polecane książki/”:{{Parametr|wzór|{{Ns:Template}}:Polecane książki/{{((}}_{{))}}}}. * {{Code|start}} - od jakiej liczby ma liczyć strony (domyślną wartością jest {{Code|1}}, od której zaczyna się liczenie stron o podany wzorze numeracyjnym), * {{Code|wzór}} - wzór według tego, co ma sprawdzając, czy one pasują do niego. Parametr {{Code|wzór}} ma w sobie {{font|color=blue|<nowiki>{{_}}</nowiki>}}, za którą podstawiany jest numer w postaci liczby naturalnej innej niż zero. === Przykłady użycia === Przykład z tą funkcją znajduje się w kodzie w szablonie: {{s|Liczba list wybranych książek}}, która po wywołaniu wypluwa wynik: * {{Code|{{s|Liczba list wybranych książek|Polecane książki}}}} → {{Tt|{{Liczba list wybranych książek|Polecane książki}}}} * {{Code|{{s|Liczba list wybranych książek|Nowe podręczniki miesiąca}}}} → {{Tt|{{Liczba list wybranych książek|Nowe podręczniki miesiąca}}}} * {{Code|{{s|Liczba list wybranych książek|Wyróżnienia książek miesiąca}}}} → {{Tt|{{Liczba list wybranych książek|Wyróżnienia książek miesiąca}}}} == {{Code|p["MinimalnyNumerSpośródNieodpowiednikowychZmiennych"](frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["MinimalnyNumerSpośródNieodpowiednikowychZmiennych"]=function(frame)...end; </syntaxhighlight> Szablon szuka minimalny numer wśród zmiennych szablonu o pewnej podstawie tego numerowanego schemacie "<zmienna>(%d*)". * {{Code|zmienna}} - podstawa parametru numerowanego liczbami lub ciągiem pustym, * {{Code|odpowiednik}} - czy ma zaufać jego odpowiednikowi nienazwanemu szablonu. Szablon przekształca wartość parametru {{Code|zmienna}} do czystego tekstu, względem wyrażeń regularnych {{lpr|Lua}}. Parametry: zmienna i odpowiednik, to parametry ramki. * Popatrz na definicję przykładu - szablonu: {{s|Wikibooks/Przykład/MinimalnyNumerSpośródNieodpowiednikowychZmiennych}}. === Przykład przy pomocy szablonu z definicją z tą funkcją === * {{Code|{{s|Wikibooks/Przykład/MinimalnyNumerSpośródNieodpowiednikowychZmiennych|zmienna{{=}}parametr|odpowiednik{{=}}|parametr3{{=}}tak|parametr5{{=}}tak|subnazwa=tak}}}} → {{Tt|{{Wikibooks/Przykład/MinimalnyNumerSpośródNieodpowiednikowychZmiennych|zmienna=parametr|odpowiednik=|parametr3=tak|parametr5=tak}}}} == {{Code|p.IleJestTakichNieodpowiednikowychZmiennych(frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.IleJestTakichNieodpowiednikowychZmiennych=function(frame)...end; </syntaxhighlight> Funkcja szuka wśród parametrów szablonu o pewnej podstawie tego numerowanego schemacie "<zmienna>(%d*)". * {{Code|zmienna}} - podstawa nazwowa parametru numerowanego, * {{Code|odpowiednik}} - czy ma ufać parametrowi nienazwanemu szablonu. Szablon przekształca wartość parametru {{Code|zmienna}} do czystego tekstu, względem wyrażeń regularnych {{lpg|Lua}}. Parametry: {{Code|zmienna}} i {{Code|odpowiednik}}, to parametry ramki. * Popatrz na definicję przykładu - szablonu: {{s|Wikibooks/Przykład/IleJestTakichNieodpowiednikowychZmiennych}}. === Przykład przy pomocy szablonu z definicją z tą funkcją === * {{Code|{{s|Wikibooks/Przykład/IleJestTakichNieodpowiednikowychZmiennych|zmienna{{=}}parametr|odpowiednik{{=}}|parametr1{{=}}tak|parametr2{{=}}tak|subnazwa=tak}}}} → {{Tt|{{Wikibooks/Przykład/IleJestTakichNieodpowiednikowychZmiennych|zmienna=parametr|odpowiednik=|parametr1=tak|parametr2=tak}}}} == {{Code|p["Parametr w tablicy nazw"](frame)}} == Funkcję uruchamia się w ramce jako dziecko w jakimś szablonie rodzicu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Parametr w tablicy nazw"]=function(frame)...end; </syntaxhighlight> Funkcja wywoływana w postaci ramki szuka parametru w tablicy podanych parametrów. * {{Code|parametry}} - lista parametrów oddzielonych średnikiem, * {{Code|pozycja}} - szukana lista w tablicy parametrów, * {{Code|od dużej}} - czy parametr i elementy listy mają być zamieniane od dużej litery. Funkcja, jeżeli wyszukała w tej tablic parametr (pozycję) zwraca wartość {{Code|tak}}, w przeciwnym wypadku zwraca {{Code|nil}}, wartość języka {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, która po transformacji na wikikod jest zamieniana na ciąg pusty. === Przykłady użycia funkcji === * {{Code|{{m|Ramka|Parametr w tablicy nazw|parametry{{=}}parametr1;parametr2;parametr3|pozycja{{=}}parametr2}}}} → {{Tt|{{#invoke:Ramka|Parametr w tablicy nazw|parametry=parametr1;parametr2;parametr3|pozycja=parametr2}}}} * {{Code|{{m|Ramka|Parametr w tablicy nazw|parametry{{=}}parametr1;parametr2;parametr3|pozycja{{=}}parametr4}}}} → {{Tt|{{#invoke:Ramka|Parametr w tablicy nazw|parametry=parametr1;parametr2;parametr3|pozycja=parametr4}}}} * {{Code|{{m|Ramka|Parametr w tablicy nazw|parametry{{=}}parametr1;parametr2;parametr3|pozycja{{=}}Parametr2|od dużej{{=}}tak}}}} → {{Tt|{{#invoke:Ramka|Parametr w tablicy nazw|parametry=parametr1;parametr2;parametr3|pozycja=Parametr2|od dużej=tak}}}} {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> j6hhk5nl07k99wjijiuxogkosfy5qs6 4 63252 541361 535356 2026-04-30T09:22:07Z Persino 2851 /* {{Code|p["PełnaNazwaStronicowejKsiążki"]()}} */ 541361 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Książkowe}}|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 ksiazkowe_modul=require("Module:Książkowe"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł służy do obsługi na nazwach pełnych nazw stron {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, które są odpowiednio przekształcone, nie jak w funkcjach nazw {{ld2|Nazwy}}, która służy na bezpośredniego operowania na nazwach bez transformatowania nazw, a {{ld2|Książkowe}} dodatkowo transformuje nazwy, w fazie początkowej, tzn. jego argument, którym jest pełna nazwa strony, tylko jeden raz, i dzieli go na poszczególne nazwy możliwie minimalne przy pomocy tablicy: <syntaxhighlight lang="lua"> local tabela_nazw={}; </syntaxhighlight> która tworzona jest jako pusta tablica, której nie można modyfikować, tylko wsadzać do kolejnych funkcji nazw w omawianym module. Poniższe funkcje mogą być wywołane w wersji ramkowej jako w postaci wikikodu: <syntaxhighlight lang="mediawiki"> {{#invoke:Książkowe|NazwaPrzestrzeni|Wikibooks:Moduły/Książkowe}} </syntaxhighlight> lub w wersji funkcyjnej programowej w języku {{lpg|Lua}} w {{lpr|Scribunto}}: <syntaxhighlight lang="lua"> local ksiazkowe_modul=require("Module:Książkowe"); local tabela_nazw={}; local nazwa_oryginalna="Wikibooks:Moduły/Książkowe"; -- Wynikiem poniższego wywołania jest: "Wikibooks"; local nazwa_przestrzeni=ksiazkowe_modul["NazwaPrzestrzeni"](nazwa_oryginalna,tabela_nazw); </syntaxhighlight> Wynikiem powyższego wywołania jest: "Wikibooks", z której są usunięte wszystkie kody HTML i inne elementy według innych funkcji zdefiniowanej podanej do funkcji, czyli nawet w sumie zdekodowania zakodowanej pełnej nazwy strony przedstawionej w postaci zakodowanej w postaci kodów HTML i URL, ze strony nazwy oryginalnej. Użycie powyżej nazwy: "NazwaPrzestrzeni", jest przykładowe, ale tutaj można użyć innej nazwy symbolizującą funkcję nazw, które są podane poniżej. Nazwy zakodowane kodami HTML, w tym przypadku mają one wzór: {{Code|&amp;#(%d+)}} lub {{Code|&amp;#x(%x+)}}, według wyrażeń regularnych {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którym odpowiadają pewne nazwy. Też mogą być zakodowane funkcją: {{Code|mw.uri.encode}}, a je odkodowuje się: {{Code|mw.uri.decode}}. A to wszystko robi funkcja: {{Code|html_modul.DeodeHtml()}} (gdzie: {{Code|html_modul}}, jest to zmienna modułu: {{Code|„{{ld2|Html}}”}}), do odkodowania nazwy zamiany kodów HTML na odpowiednie znaki, i dekodowania URL adresów stron internetowych, ale tutaj zastosowana do nazw. == {{Code|NazwaKsiazkawaSilnik()}} == Funkcja silnik potrzebna do budowy funkcji nazw, podane w poniższych rozdziałach, wykorzystują tę funkcję, o definicji: <syntaxhighlight lang="lua"> local function NazwaKsiazkawaSilnik(frame,funkcja_nazw,tabela_nazw)...end; </syntaxhighlight> Parametry w tablicy ramki {{Code|frame}} są: * {{Code|nazwa}} lub {{Code|1}} - pełna, ewentualnie zakodowana URL i HTML, lub inaczej, nazwa przestrzeni nazw w przeciwieństwie do pełnej nazwy według modułu {{ld2|Nazwy}}, * {{Code|bez transformacji}} - niepuste, wtedy są wywoływane czysto funkcje w {{ld2|Nazwy}} bez żadnego odkodowania URL i HTML, * {{Code|funkcja}} - dodatkowa funkcja nazw potrzebna do transformacji pełnej nazwy strony, domyślnie jest wywoływana funkcja {{Code|p[""]}}, * {{Code|funkcja decode}} - nazwa funkcji drugiej do dekodowania, domyślnie jest to {{Code|html_modul.DecodeHtml()}}, * {{Code|moduł}} - nazwa modułu, w której jest zawarta funkcja: {{Code|funkcja}}, ale domyślnie dla: {{Code|p[""]}}, jest to o domyślnej nazwie: {{Code|{{ld|Książkowe}}}}, * {{Code|moduł decode}} - nazwa modułu funkcji: {{Code|html_modul.DecodeHtml()}}, domyślnie jest to: {{Code|{{Ld|Html}}}}. Jeżeli zmienna {{Code|bez transformacji}} jest pusta lub niepodana, to względem powyższych zmiennych jest dekodowana, a później transformowana do pewnej wartości w postaci pewnego szeregu nazw. W ten sposób uzyskana nazwa jest zwracana przez funkcję. Można tworzyć nowe funkcje, nawet te zdefiniowane, i nowo-zdefiniowane przez programistę języka {{lpg|Lua}}, w module {{Code|{{ld2|Książkowe}}}}, przy pomocy schematu: <syntaxhighlight lang="lua"> p["NazwaFunkcjiNazw"]=function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"NAZWAFUNKCJINAZW",tabela_nazw); end; </syntaxhighlight> Przykładem nazwy: {{Code|„NazwaFunkcjiNazw”}} jest: {{Code|„NazwaPrzestrzeni”}}, przy drugi parametrze funkcji: {{Code|NazwaKsiazkawaSilnik}}, czyli: {{Code|„NAZWAFUNKCJINAZW”}}, przyjmuje, wtedy wartość: {{Code|„NAZWAPRZESTRZENI”}}. Funkcja lub funkcje zdefiniowane do dekodowana podana w postaci parametrów dla wartości zawartch w zmiennych: {{Code|funkcja decode}} i {{Code|moduł decode}}, a nawet do transformacji: {{Code|funkcja}} i {{Code|moduł}}, mogą być umieszczone w dowolnym module lub modułach, lub nawet w module samego programu, a zarazem biblioteki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. == {{Code|p[""]()}} == Funkcja tożsamościowa nazw, która zwraca wartość taką samą, jaką podaliśmy jako argument. <syntaxhighlight lang="lua"> local ksiazkowe_modul=require("Module:Książkowe"); local nazwa_oryginalna="Wikibooks:Moduły/Książkowe"; local nazwa_wyjsciowa=ksiazkowe_modul[""](nazwa_oryginalna); if(nazwa_oryginalna==nazwa_wyjsciowa)then return "Dwie nazwy są sobie równe"; end; return "Dwie nazwy są sobie nierówne"; </syntaxhighlight> == {{Code|p["NazwaPrzestrzeni"]()}} == Funkcja wykorzystuje funkcję nazw: {{Code|„NAZWAPRZESTRZENI”}}, modułu nazw: {{Code|{{ld2|Nazwy}}}}, do liczenia nazwy przestrzeni nazw, ale przed tym wykorzystaniem, dekoduje pełne nazwy względem pewnych funkcji w modułach, lub tego nie robi, jeżeli jest zdefiniowana niepusta zmienna: {{Code|bez transformacji}}, w tablicy ramki tej funkcji. <syntaxhighlight lang="lua"> p["NazwaPrzestrzeni"]=function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"NAZWAPRZESTRZENI",tabela_nazw); end; </syntaxhighlight> == {{Code|p["NazwaPrzestrzeniKsiążki"]()}} == Funkcja wykorzystuje funkcję nazw: {{Code|„NAZWAPRZESTRZENIKSIĄŻKI”}}, modułu nazw: {{Code|{{ld2|Nazwy}}}}, do liczenia nazwy przestrzeni nazw książki bez nazwy przestrzeni dostępnych na polskim {{NAZWASERWISU|link=tak|klucz projektu=b|wikipedia=tak|po=ie}}, ale przed tym wykorzystaniem, dekoduje pełne nazwy względem pewnych funkcji w modułach, lub tego nie robi, jeżeli jest zdefiniowana niepusta zmienna: {{Code|bez transformacji}}, w tablicy ramki tej funkcji. <syntaxhighlight lang="lua"> p["NazwaPrzestrzeniKsiążki"]=function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"NAZWAPRZESTRZENIKSIĄŻKI",tabela_nazw); end; </syntaxhighlight> == {{Code|p["NazwaTytułuKsiążki"]()}} == Funkcja wykorzystuje funkcję nazw: {{Code|„SUBNAZWAKSIĄŻKI”}}, modułu nazw: {{Code|{{ld2|Nazwy}}}}, do liczenia sub nazwy książki bez nazwy przestrzeni nazw książki, czyli służy do liczenia tytułu książki, ale przed tym wykorzystaniem, dekoduje pełne nazwy względem pewnych funkcji w modułach, lub tego nie robi, jeżeli jest zdefiniowana niepusta zmienna: {{Code|bez transformacji}}, w tablicy ramki tej funkcji. <syntaxhighlight lang="lua"> p["NazwaTytułuKsiążki"]=function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"SUBNAZWAKSIĄŻKI",tabela_nazw); end; </syntaxhighlight> == {{Code|p["NazwaArtykułuKsiążki"]()}} == Funkcja wykorzystuje funkcję nazw: {{Code|„NAZWAARTYKUŁUKSIĄŻKI”}}, modułu nazw: {{Code|{{ld2|Nazwy}}}}, do liczenia nazwy artykułu książki bez nazwy książki, ale przed tym wykorzystaniem dekoduje, pełne nazwy względem pewnych funkcji w modułach, lub tego nie robi, jeżeli jest zdefiniowana niepusta zmienna: {{Code|bez transformacji}}, w tablicy ramki tej funkcji. <syntaxhighlight lang="lua"> p["NazwaArtykułuKsiążki"]=function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"NAZWAARTYKUŁUKSIĄŻKI",tabela_nazw); end; </syntaxhighlight> == {{Code|p["NazwaKsiążki"]()}} == Funkcja wykorzystuje funkcję nazw: {{Code|„NAZWAKSIĄŻKI”}}, modułu nazw: {{Code|{{ld2|Nazwy}}}}, do liczenia nazwy książki bez nazwy przestrzeni nazw dostępne na polskim {{NAZWASERWISU|link=tak|klucz projektu=b|wikipedia=tak|po=ie}}, bez nazwy artykułu danego artykułu, ale przed tym wykorzystaniem, dekoduje pełne nazwy względem pewnych funkcji w modułach, lub tego nie robi, jeżeli jest zdefiniowana niepusta zmienna: {{Code|bez transformacji}}, w tablicy ramki tej funkcji. <syntaxhighlight lang="lua"> p["NazwaKsiążki"]=function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"NAZWAKSIĄŻKI",tabela_nazw); end; </syntaxhighlight> == {{Code|p["PełnaNazwaKsiążki"]()}} == Funkcja wykorzystuje funkcję nazw: {{Code|„PEŁNANAZWAKSIĄŻKI”}}, modułu nazw: {{Code|{{ld2|Nazwy}}}}, do liczenia pełnej nazwy książki z przestrzenią nazw ksiązki i z nazwą przestrzeni nazw dostępne na polskim: {{NAZWASERWISU|link=tak|klucz projektu=b|wikipedia=tak}}, bez nazwy artykułu podanego artykułu, ale przed tym wykorzystaniem, dekoduje pełne nazwy względem pewnych funkcji w modułach, lub tego nie robi, jeżeli jest zdefiniowana niepusta zmienna: {{Code|bez transformacji}}, w tablicy ramki tej funkcji. <syntaxhighlight lang="lua"> p["PełnaNazwaKsiążki"]=function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"PEŁNANAZWAKSIĄŻKI",tabela_nazw); end; </syntaxhighlight> == {{Code|p["PełnaNazwaArtykułu"]()}} == Funkcja wykorzystuje funkcję nazw: {{Code|„PEŁNANAZWASTRONY”}}, modułu nazw: {{Code|{{ld2|Nazwy}}}}, do liczenia pełnej nazwy strony (artykułu), ale przed tym wykorzystaniem, dekoduje pełne nazwy względem pewnych funkcji w modułach, lub tego nie robi, jeżeli jest zdefiniowana niepusta zmienna: {{Code|bez transformacji}}, w tablicy ramki tej funkcji. <syntaxhighlight lang="lua"> p["PełnaNazwaArtykułu"]=function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"PEŁNANAZWASTRONY",tabela_nazw); end; </syntaxhighlight> == {{Code|p["NazwaArtykułu"]()}} == Funkcja wykorzystuje funkcję nazw: {{Code|„NAZWASTRONY”}}, modułu nazw: {{Code|{{ld2|Nazwy}}}}, do liczenia nazwy stron (artykułów) bez nazwy przestrzeni nazw dostępnych na polskim {{NAZWASERWISU|link=tak|klucz projektu=b|po=ie}}, ale przed tym wykorzystaniem, dekoduje pełne nazwy względem pewnych funkcji w modułach, lub tego nie robi, jeżeli jest zdefiniowana niepusta zmienna: {{Code|bez transformacji}}, w tablicy ramki tej funkcji. <syntaxhighlight lang="lua"> p["NazwaArtykułu"]=function(frame,tabela_nazw) tabela_nazw=tabela_nazw or {}; return NazwaKsiazkawaSilnik(frame,"NAZWASTRONY",tabela_nazw); end; </syntaxhighlight> == {{Code|p["PełnaNazwaStronicowejKsiążki"]()}} == Funkcja liczy nazwę książki, ale wpierw, musi zdekodować pełną nazwę strony, zwykle z URL i HTML, lub tych zdefiniowanych, a gdy nie podana jest nazwa strony, to liczy pełną nazwę artykułu według funkcji: {{Code|PełnaNazwaKsiążki}}, a gdy pełna nazwa strony przybiera wartość pustą według łańcuchów {{lpg|Lua}}, czyli {{Code|""}}, wtedy wykorzystuje funkcję systemową modułu nazw {{Code|{{ld2|Nazwy}}}}, czyli: „{{Code|PEŁNANAZWAKSIĄŻKI}}”, i liczy w ten sposób ciąg pusty, w przeciwnym wypadku, gdy pełna nazwa strony posiada na początku dwukropek, wtedy jest liczona pełna nazwa książki według funkcji: „{{Code|PEŁNANAZWAKSIĄŻKI}}”. W innym wypadku, gdy tak nie jest, wtedy jest liczona nazwa przestrzeni nazw funkcją: „{{Code|NAZWAPRZESTRZENI}}”, by wskazać, że strona nie jest w przestrzeni głównej, wtedy jest liczona pełna nazwa książki na podstawie: „{{Code|PEŁNANAZWAKSIĄŻKI}}”. A jeżeli jednak tak nie jest, bo mamy wtedy możliwą przestrzeń główną według wskazań początkowych, wtedy wypadałoby policzyć nazwę książki, która musi istnieć według z: „{{Code|NAZWAKSIĄŻKI}}”, a jeśli ona rzeczywiście nie istnieje, to może być to przestrzeń {{Np|Wikijunior|link=tak}}, wtedy liczymy: „{{Code|PEŁNANAZWAKSIĄŻKI}}”, a jeżeli to nie jest ta przestrzeń nazw dla istniejącej na pewno strony, tylko ta strona nie istnieje, wtedy musimy policzyć nazwę przestrzeni nazw dostępną na polskim {{NAZWASERWISU|link=tak|klucz projektu=b|wikipedia=tak|po=ie}}, i nazwę przestrzeni książki funkcją: {{Code|NazwaPrzestrzeniKsiążki}}, aktualnej strony, które łączymy razem w pełną nazwę przestrzeni książki z nazwą strony podanej jako pierwszy argument naszej rozważanej funkcji, co na samym końcu pozostało policzyć: „{{Code|PEŁNANAZWAKSIĄŻKI}}”, którą jest wykryta pełna nazwa książki na samym końcu obliczeń. Nasza funkcja liczy pełną nazwę książki, do której należy podana nazwa książki, która może mieć niepełny adres, według metod powiedzianych powyżej, sprawdzając różne możliwości, wtedy otrzymujemy pełną nazwą książki na samym końcu, do której należy ten artykuł, który został podany, szczególną postacią pełnej nazwy artykułu jest nazwa książki. Przykładem użycia: <syntaxhighlight lang="lua"> local ksiazkowe_modul=require("Module:Książkowe"); local tabela_nazw={}; local nazwa_artykułu="Ksiązka/Artykuł"; local nazwa_ksiazki=ksiazkowe_modul["PełnaNazwaStronicowejKsiążki"](nazwa_artykułu,tabela_nazw); </syntaxhighlight> Wtedy możliwymi wartościami pełnych wartości nazw artykułów dla wartości niepełnej nazwy artykułu: {{Code|Książka/Artykuł}}, są: * {{Code|Książka/Artykuł}} - gdy strona leży w przestrzeni nazw {{Np|(main)|link=tak}}, * {{Code|Wikijunior:Książka/Artykuł}} - gdy strona leży w przestrzeni nazw {{Np|Wikijunior|link=tak}}, * {{Code|Wikibooks:Brudnopis/<użytkownik>/Książka/Artykuł}} - gdy początkowy artykuł podanej w nawie rozważanej funkcji leży w niby-przestrzeni nazw: '''{{lr2|Brudnopis}}/<użytkownik>''', w przestrzeni nazw {{Np|Project|link=tak}}, * {{Code|Wikipedysta:<użytkownik>/Książka/Artykuł}} - gdy początkowy artykuł podanej w nawie rozważanej funkcji leży w niby-przestrzeni nazw: '''{{Np|User|link=tak}}:<użytkownik>''', w przestrzeni nazw {{Np|User|link=tak}}. Jeżeli mamy te artykuły w możliwych do uzyskania postaciach, to wtedy jest liczona ich pełna nazwa książki z funkcji: „{{Code|PEŁNANAZWAKSIĄŻKI}}”, i to jest ta wartość, jaką uzyskujemy z funkcji: {{Code|p["PełnaNazwaStronicowejKsiążki"]()}}, zawartej w module: {{Code|{{ld2|Książkowe}}}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> rrhhgm16ex0xlcnkkgn8jxpa3tkh5h9 4 63280 541364 541092 2026-04-30T10:46:43Z Persino 2851 541364 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Sekcja referencyjna}}|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 sekcja_referencyjna_modul=require("Module:Sekcja referencyjna"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Ta funkcja o nazwie: {{Code|{{sr|#p["Sekcja referencyjna"]()|p=Sekcja referencyjna}}}}, jak i szablon: {{Code|{{s|Sekcja referencyjna}}}} (lub jego wersja skrótowa: {{Code|{{s|sr}}}} - w postaci przekierowania do jego dłuższej wersji), służy do wyświetlania na normalnej lub stronie zbiorczej linków inteligentnych danego podręcznika, jeżeli podamy jego artykuł wraz z, lub bez, nagłówka, lub nagłówek z hashem, z artykułem w zmiennej w: {{Code|podstrona}} (lub ten parametr podany w wersji skrótowej {{Code|p}}), też można linkować do strony głównej podręcznika, nie podając żadnego artykułu w funkcji w: {{sr|#p["Sekcja referencyjna"]()|p=Sekcja referencyjna}}, w zmiennej: {{Code|strona}} (lub w wersji jego skrótowej {{Code|s}}), i w zmiennej w jego pierwszym parametrze numerowanym, lub w jego wersji szablonowej. Ta funkcja lub jego odpowiednik szablonowy wyświetla na stronie normalnej artykułu link do artykułu, a na stronie zbiorczej link do identyfikatora jakiegoś obiektu na stronie. Inne funkcje użyte w module: {{Code|{{ld2|Sekcja referencyjna}}}}, są funkcjami pomocniczymi do głównej jego funkcji, która służy do wywołania w ramce w jego odpowiedniku szablonowym, podany tutaj na samym początku tej strony, te funkcje służą też do użycia w innych modułach, np.: {{ld2|StronicowyParser/Potrzebne}}. Funkcje tutaj opisują obsługę linków inteligentnych (tzw. linki inteligentne), który koloruje linki w zależności do jakiej kategorii szablon zaliczy stronę wskazaną w nim. Zestaw możliwych kodów linkowych, znajduje się na stronie {{s|Link wewnętrzny}}, w miejscu pod tabelą nawigacyjną {{s|Tabela nawigacyjna}}, według jego wikikodu opisu. === Dlaczego te funkcje w opisywanym module, jak i szablon, o który jest zdefiniowany === Moduł {{ld2|Sekcja referencyjna}}, i też szablon {{s|Sekcja referencyjna}} (używany w postaci przekierowania do niego {{s|sr}}), który wykorzystuje ten moduł do swojej definicji, zostały stworzone do używania w spisach treści, oraz wewnątrz zwyczajnych stron książki jako odnośnik do sekcji (rozdziału/podrozdziału/itp.). Ideą tego modułu (szablonu) było rozwiązanie pewnego problemu pojawiającego się, gdy strona zostanie wydrukowana w formie PDF-a, ale nie na papier. Normalnie, gdy spis treści zawiera linki do rozdziałów tworzonych normalnym sposobem (przez wikilinki), to w wydrukowanej formie te linki zostają odnośnikami bezwzględnymi do strony Wikibooks. Gdy użytkownik kliknie w taki link w PDF-ie, to zostanie przekierowany do przeglądarki WWW z otwartą stroną Wikibooks. Psuje to użytkowanie takiej strony, gdyż użytkownik zazwyczaj zakłada, że gdy kliknie na odnośnik w spisie treści, to ten przeniesie go na odpowiednią stronę ''wewnątrz'' PDF-a. Ten moduł (szablon) rozwiązuje ten problem, przez warunkową zamianę linków do stron sekcji w linki lokalne do sekcji wewnątrz strony do druku. W niektórych generatorach PDF-a taka zamiana skutkuje tym, że takie linki umieszczone w spisach treści, powodują przeniesienie do odpowiedniej strony, a nie przeskok do strony WWW (pozostałe generatory po prostu nie generują linków w ogóle). == {{Code|p.Indentyfikator_lub_podstrona_wikiadresu_strony()}} == Funkcja zwraca nagłówek strony, jeżeli istnieje, lub jego podstronę, a jeżeli ona nie ma żadnej podstrony według tego adresu, to cały ten adres, który nie jest adresem {{Strong|HTML}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Indentyfikator_lub_podstrona_wikiadresu_strony(ustep,czy_ustep)...end; </syntaxhighlight> Parametry funkcji: * {{Code|ustep}} - nazwa strony ustępu strony, co z niego robimy nazwę linku, * {{Code|czy_ustep}} - jeżeli {{Code|true}} liczy wtedy nagłówek, a jeżeli tego nie ma to podstronę. Jeżeli {{Code|ustep{{=}}nil}}, w takim razie jest zwracana wartość parametru tego, czyli {{Code|nil}}. Aby nie uzyskać identyfikatora strony, to drugi parametr, czyli {{Code|czy_ustep}}, nie może przyjmować wartości logicznej {{Code|true}}, tylko jako {{Code|false}} lub {{Code|nil}} - wtedy zwracana jest wartość argumentu {{Code|ustęp}}. A jeżeli podamy wartość {{Code|true}}, gdy zmienna {{Code|ustep}} zawiera nagłówek, to zwracany jest właśnie on bez znaku {{Code|#}}, a jeżeli nie zawiera on tego, tylko podstronę, wtedy zwracana jest jego podstrona. W przeciwny wypadku zwracana jest sama wartość argumentu {{Code|ustep}}. == {{Code|p.Nazwa_od_niewielkiej_lub_wielkiej_litery()}} == Funkcja zamienia w nazwie linku pierwszy znak, który jest od litery, aby był od dużej lub małej litery, w zależności od parametrów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwa_od_niewielkiej_lub_wielkiej_litery(nazwa,od_malej,od_duzej)...end; </syntaxhighlight> Parametry funkcji: * {{Code|nazwa}} - nazwa linku strony, * {{Code|od malej}} - zamienia pierwszą literę, pierwszy znak, nazwy linku na małą literę, * {{Code|od dużej}} - zamienia pierwszą literę, pierwszy znak, nazwy linku na dużą literę. Te parametry nie mogą się zaprzeczać między sobą, tzn. oba ostatnie parametry nie mogą być nie {{Code|true}}. W przeciwny wypadku funkcja zwraca samą nieprzekształconą nazwę strony. == {{Code|p.Strona_zbiorcza()}} == Funkcja tworzy linkna stronie zbiorczej sama do siebie do elementu wskazywanego przez stworzony nagłówek z parametrów tej funkcji. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Strona_zbiorcza(strona,podstrona,nazwa,czy_ustep,czy_pod_ustep,od_malej,od_duzej,pelnanazwajednostki)...end; </syntaxhighlight> Wartości opcjonalne powyżej przyjmują wartość {{Code|nil}}, wtedy możemy je uznać tak, jak by je, nie podaliśmy. Funkcja przyjmuje parametry podane w tym rozdziale w parametrach tej funkcji, w jego definicji skrótowej, według zmiennych podanych w parametrach zdefiniowanych jako w punkcie dla funkcji {{Code|{{sr|#p["Sekcja referencyjna"](frame)|p=Sekcja referencyjna}}}}, przy których znajduje się ich opis, podanych przy jego parametrach. Nagłówek strony jest tworzony z: {{Code|strona}} i {{Code|podstrona}}, także na podstawie parametru {{Code|czy_pod_ustep}}, gdy magłówek jest pusty, on jesty wyznaczany z: {{Code|pelnanazwajednostki}}, a później jest do tego wykorzystywana zmienna: {{Code|czy_pod_ustep}}, do liczenia właściwego nagłówka. Parametr nazwy linku jest w zmiennej {{Code|nazwa}}, a jezeli ona nie istnieje, wtedy wykorzystujemy do tego element {{Code|strona}}, do którego wykorzystywana jest {{Code|{{sr|#p.Indentyfikator_lub_podstrona_wikiadresu_strony()|p=Sekcja referencyjna}}}}. Funkcja {{Code|{{sr|#p.Nazwa_od_niewielkiej_lub_wielkiej_litery()|p=Sekcja referencyjna}}}} ustala odpowiednio zmodyfikowaną nazwę, według zmiennych, które powinny być niesprzeczne, chodzi tu o: {{Code|od_malej}} i {{Code|od_duzej}}, w przeciwnym wypadku lub jeżeli one nie są ustawione, wtedy nazwa linku pozostaje niezmieniona. Funkcja zwraca trzy parametry jednocześnie, czyli nazwę strony, jego nagłówek i nazwę linku. == {{Code|p.Wolumin()}} == Funkcja tworzy link do podnego artykułu podręcznika, ewentualnie z nazwą nagłówka. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Wolumin(strona,podstrona,nazwa,czy_ustep,od_malej,od_duzej,pelnanazwajednostki)...end; </syntaxhighlight> Wartości opcjonalne powyżej przyjmują wartość {{Code|nil}}, wtedy możemy je uznać tak, jak by je, nie podaliśmy. Funkcja przyjmuje parametry podane w tym rozdziale w parametrach tej funkcji, w jego definicji skrótowej, według zmiennych podanych w parametrach zdefiniowanych jako w punkcie dla funkcji {{Code|{{sr|#p["Sekcja referencyjna"](frame)|p=Sekcja referencyjna}}}}, przy których znajduje się ich opis, podanych przy jego parametrach. Jeżeli parametr {{Code|strona}} nie istnieje, to ona jest tworzona na podstawie {{Code|pelnanazwajednostki}}, nie używajac parametru {{Code|podstrona}}. A jeżeli on istnieje, to nowa wartość {{Code|strona}} jest tworzona ze starego {{Code|strona}} i {{Code|podstrona}}. Funkcja zwraca dwa parametry jednocześnie, czyli policzoną nazwę strony, policzonej z parametru {{Code|strona}},ewentualnie {{Code|podstrona}} i nazwę linku z {{Code|nazwa}}, a jeżeli ona nie istnieje to ona jest tworzona z: {{Code|strona}}, wykorzystując funkcję {{Code|{{sr|#p.Indentyfikator_lub_podstrona_wikiadresu_strony()|p=Sekcja referencyjna}}}}. == {{Code|p["Sekcja referencyjna"](frame)}} == Szablon linków inteligentnych z kodami na stronie {{s|Link wewnętrzny}}, który się mieści w tabeli wywołania szablonowego {{s|Tabela nawigacyjna}}, linkujący się do stron tego samego podręcznika, w której został wywołany, ewentualnie do jego identyfikatora danego elementu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Sekcja referencyjna"]=function(frame)...end; </syntaxhighlight> Parametrami tablicy ramki modułu, które są podane w rodzicu w szablonie lub w samej ramce, jeżeli jest podany parametr {{Parametr|wyspecjalizowana|tak}} w samej ramce, a one są: * {{Code|1}}, {{Code|s}} lub {{Code|strona}} - jest to artykuł w podręczniku, ewentualnie z nagłówkiem, zdefiniujmy go jako: {{Code|strona}}, * {{Code|2}}, {{Code|n}} lub {{Code|nazwa}} - nazwa linku wyświetlana w artykule, zdefiniujmy go jako: {{Code|nazwa}}, * {{Code|3}}, {{Code|p}} lub {{Code|podstrona}} - podstrona dodawana do linku podczas rozważać, wtedy artykuł, będzie o jeden lub wyżej, głębiej w drzewie danej przestrzeni nazw, zdefiniujmy go jako: {{Code|podstrona}}, * {{Code|4}}. {{Code|u}} lub {{Code|ustęp}} - jeśli przyjmuje wartość niepustą, to nazwa wyświetlana linku jest jego nagłówek, jeżeli istnieje, lub jego podstrona albo sama strona, w przypadku przestrzeni nazw {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}} oraz nibyprzestrzeni nazw {{lr2|Brudnopis}}, w przestrzeni nazw {{Np|Project|link=tak}}, a także przestrzeni użytkownika {{Np|User|link=tak}}, a w przypadku nie podania nazwy strony {{Code|strona}} (lub jego skrót: {{Code|s}}) lub {{Code|1}}, to parametr {{Code|ustęp}} zachowuje się odwrotnie, wtedy nazwę strony, do której linkuje szablon, przyjmujemy domyślnie, że jest to nazwa książki, w przestrzeniach nazw w dwóch pierwszych nie widać różnicy działania tego parametru, już jest różnica w nibyprzestrzeniach nazw dwóch ostatnich, tutaj ten szablon podaje subnazwę książki, a nie jego adres, gdzie przy {{Parametr|ustęp|tak}} (lub jego synonim numerowany: {{Parametr|4|tak}}) (lub jego skrót: {{Parametr|u|tak}}) podaje cały adres, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|czy_ustęp}}, * {{Code|m}}, {{Code|od małej}} - jeśli niepuste, wyświetlany jest link od małej litery, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|od malej}}, * {{Code|d}}, {{Code|od dużej}} - jeśli niepuste, wyświetlany jest link od dużej litery, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|od dużej}}, * {{Code|t}}, {{Code|pod-ustęp}} - na stronach zbiorczych skraca nazwę nagłówka, która na stronie artykułów podręcznika byłaby nazwą strony, do substrony, zdefiujmy go jako: {{Code|czy_pod_ustep}}. ---- W tej funkcji jeszcze jest liczona zmienna: {{Code|pelnanazwajednostki}}, oznaczająca: pełna nazwa jednostki uzyskana jest, dzięki podanym zmiennym pudełkowym {{m|Pudełko}}, czyli według: {{Code|nazwa przestrzeni nazw}} i {{Code|nazwa jednostki}}, a jeżeli jakaś z tych zmiennych nie została podana, to traktowana jest, jakby była podana, w takim razie te niepodane są liczona na podstawie parametrów aktualnej strony, a jeśli są niepodane, wtedy jest sprawdzane jedynie ich nieistnienie, na podstawie tego wszystkiego jest liczona pełna nazwa jednostki, przy pomocy funkcji: {{sr|#p["Pełna nazwa jednostki"](frame,...)|p=Pudełko/Tom II}}, z tej zmiennej jest liczona pełna nazwa książki, używając funkcji: {{sr|#m["PEŁNANAZWAKSIĄŻKI"]()|p=Nazwy/Tom IV}} w funkcjach: {{Code|{{sr|#p.Strona_zbiorcza()|p=Sekcja referencyjna}}}} i {{Code|{{sr|#p.Wolumin()|p=Sekcja referencyjna}}}}, parametry pudełek mogą wskazywać na inny artykuł niż aktualny, ale tak nie musi być, byle tylko adres książki się zgadzał z tą aktualną, przy nie podaniu parametrów przestrzennych i jednostki, a z nimi adres woluminy może być inny. ---- Te parametry powyżej są jednocześnie parametrami szablonu {{s|Sekcja referencyjna}} (lub jego wersji skrótowej {{s|sr}}). Te parametry możemy podać też w formie funkcyjnej: <syntaxhighlight lang="lua"> local sekcja_referencyjna_modul=require("Module:Sekcja referencyjna"); local link=sekcja_referencyjna_modul["Sekcja referencyjna"]{args={strona=..., nazwa=.., podstrona=..., ...}}; </syntaxhighlight> W ramce funkcyjnej parametry ze znakami nienależącymi do alfabetu łacińskiego piszmy w cudzysłowach w nawiasach kwadratowych, czyli w formie: {{Code|["pod-ustęp"]{{=}}...}}, czy parametry numerowe w nawiasach bez cudzysłowu: {{Code|[1]{{=}}...}}, a parametry normalne piszemy: {{Code|strona{{=}}...}}. Funkcja w uruchamianiu ma dwa warianty, na normalnej stronie niezbiorczej uruchamiana jest funkcja {{Code|{{sr|#p.Wolumin()|p=Sekcja referencyjna}}}}, a na jakikolwiek stronie zbiorczej według Stronicowego Parsera na podstawie modułu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli strony zefiniowanej w: {{Code|{{m|StronicowyParser/StronaSubst}}}}, jest uruchamiana funkcja: {{Code|{{sr|#p.Strona_zbiorcza()|p=Sekcja referencyjna}}}} (a ta przedostatnia jest uruchamiana przez funkcję: {{Code|{{m|StronicowyParser|CzyStronaSubst}}}}, która zwraca wynik {{Code|tak}}, gdy strona dana jest bieżąca lub podana na podstawie parametrów pudełkowych: {{Code|{{m|Pudełko}}}}, która jest stroną zbiorczą, w przeciwnym wypadku mamy wynik: {{Code|nil}}, gdy nie). {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 9c75by10dytmu86qndtskecd40cen08 541365 541364 2026-04-30T11:01:03Z Persino 2851 /* {{Code|p.Strona_zbiorcza()}} */ 541365 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Sekcja referencyjna}}|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 sekcja_referencyjna_modul=require("Module:Sekcja referencyjna"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Ta funkcja o nazwie: {{Code|{{sr|#p["Sekcja referencyjna"]()|p=Sekcja referencyjna}}}}, jak i szablon: {{Code|{{s|Sekcja referencyjna}}}} (lub jego wersja skrótowa: {{Code|{{s|sr}}}} - w postaci przekierowania do jego dłuższej wersji), służy do wyświetlania na normalnej lub stronie zbiorczej linków inteligentnych danego podręcznika, jeżeli podamy jego artykuł wraz z, lub bez, nagłówka, lub nagłówek z hashem, z artykułem w zmiennej w: {{Code|podstrona}} (lub ten parametr podany w wersji skrótowej {{Code|p}}), też można linkować do strony głównej podręcznika, nie podając żadnego artykułu w funkcji w: {{sr|#p["Sekcja referencyjna"]()|p=Sekcja referencyjna}}, w zmiennej: {{Code|strona}} (lub w wersji jego skrótowej {{Code|s}}), i w zmiennej w jego pierwszym parametrze numerowanym, lub w jego wersji szablonowej. Ta funkcja lub jego odpowiednik szablonowy wyświetla na stronie normalnej artykułu link do artykułu, a na stronie zbiorczej link do identyfikatora jakiegoś obiektu na stronie. Inne funkcje użyte w module: {{Code|{{ld2|Sekcja referencyjna}}}}, są funkcjami pomocniczymi do głównej jego funkcji, która służy do wywołania w ramce w jego odpowiedniku szablonowym, podany tutaj na samym początku tej strony, te funkcje służą też do użycia w innych modułach, np.: {{ld2|StronicowyParser/Potrzebne}}. Funkcje tutaj opisują obsługę linków inteligentnych (tzw. linki inteligentne), który koloruje linki w zależności do jakiej kategorii szablon zaliczy stronę wskazaną w nim. Zestaw możliwych kodów linkowych, znajduje się na stronie {{s|Link wewnętrzny}}, w miejscu pod tabelą nawigacyjną {{s|Tabela nawigacyjna}}, według jego wikikodu opisu. === Dlaczego te funkcje w opisywanym module, jak i szablon, o który jest zdefiniowany === Moduł {{ld2|Sekcja referencyjna}}, i też szablon {{s|Sekcja referencyjna}} (używany w postaci przekierowania do niego {{s|sr}}), który wykorzystuje ten moduł do swojej definicji, zostały stworzone do używania w spisach treści, oraz wewnątrz zwyczajnych stron książki jako odnośnik do sekcji (rozdziału/podrozdziału/itp.). Ideą tego modułu (szablonu) było rozwiązanie pewnego problemu pojawiającego się, gdy strona zostanie wydrukowana w formie PDF-a, ale nie na papier. Normalnie, gdy spis treści zawiera linki do rozdziałów tworzonych normalnym sposobem (przez wikilinki), to w wydrukowanej formie te linki zostają odnośnikami bezwzględnymi do strony Wikibooks. Gdy użytkownik kliknie w taki link w PDF-ie, to zostanie przekierowany do przeglądarki WWW z otwartą stroną Wikibooks. Psuje to użytkowanie takiej strony, gdyż użytkownik zazwyczaj zakłada, że gdy kliknie na odnośnik w spisie treści, to ten przeniesie go na odpowiednią stronę ''wewnątrz'' PDF-a. Ten moduł (szablon) rozwiązuje ten problem, przez warunkową zamianę linków do stron sekcji w linki lokalne do sekcji wewnątrz strony do druku. W niektórych generatorach PDF-a taka zamiana skutkuje tym, że takie linki umieszczone w spisach treści, powodują przeniesienie do odpowiedniej strony, a nie przeskok do strony WWW (pozostałe generatory po prostu nie generują linków w ogóle). == {{Code|p.Indentyfikator_lub_podstrona_wikiadresu_strony()}} == Funkcja zwraca nagłówek strony, jeżeli istnieje, lub jego podstronę, a jeżeli ona nie ma żadnej podstrony według tego adresu, to cały ten adres, który nie jest adresem {{Strong|HTML}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Indentyfikator_lub_podstrona_wikiadresu_strony(ustep,czy_ustep)...end; </syntaxhighlight> Parametry funkcji: * {{Code|ustep}} - nazwa strony ustępu strony, co z niego robimy nazwę linku, * {{Code|czy_ustep}} - jeżeli {{Code|true}} liczy wtedy nagłówek, a jeżeli tego nie ma to podstronę. Jeżeli {{Code|ustep{{=}}nil}}, w takim razie jest zwracana wartość parametru tego, czyli {{Code|nil}}. Aby nie uzyskać identyfikatora strony, to drugi parametr, czyli {{Code|czy_ustep}}, nie może przyjmować wartości logicznej {{Code|true}}, tylko jako {{Code|false}} lub {{Code|nil}} - wtedy zwracana jest wartość argumentu {{Code|ustęp}}. A jeżeli podamy wartość {{Code|true}}, gdy zmienna {{Code|ustep}} zawiera nagłówek, to zwracany jest właśnie on bez znaku {{Code|#}}, a jeżeli nie zawiera on tego, tylko podstronę, wtedy zwracana jest jego podstrona. W przeciwny wypadku zwracana jest sama wartość argumentu {{Code|ustep}}. == {{Code|p.Nazwa_od_niewielkiej_lub_wielkiej_litery()}} == Funkcja zamienia w nazwie linku pierwszy znak, który jest od litery, aby był od dużej lub małej litery, w zależności od parametrów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwa_od_niewielkiej_lub_wielkiej_litery(nazwa,od_malej,od_duzej)...end; </syntaxhighlight> Parametry funkcji: * {{Code|nazwa}} - nazwa linku strony, * {{Code|od malej}} - zamienia pierwszą literę, pierwszy znak, nazwy linku na małą literę, * {{Code|od dużej}} - zamienia pierwszą literę, pierwszy znak, nazwy linku na dużą literę. Te parametry nie mogą się zaprzeczać między sobą, tzn. oba ostatnie parametry nie mogą być nie {{Code|true}}. W przeciwny wypadku funkcja zwraca samą nieprzekształconą nazwę strony. == {{Code|p.Strona_zbiorcza()}} == Funkcja tworzy link na stronie zbiorczej sama do siebie do elementu wskazywanego przez stworzony nagłówek z parametrów tej funkcji. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Strona_zbiorcza(strona,podstrona,nazwa,czy_ustep,czy_pod_ustep,od_malej,od_duzej,pelnanazwajednostki)...end; </syntaxhighlight> Wartości opcjonalne powyżej przyjmują wartość {{Code|nil}}, wtedy możemy je uznać tak, jak by je, nie podaliśmy. Funkcja przyjmuje parametry podane w tym rozdziale w parametrach tej funkcji, w jego definicji skrótowej, według zmiennych podanych w parametrach zdefiniowanych jako w punkcie dla funkcji {{Code|{{sr|#p["Sekcja referencyjna"](frame)|p=Sekcja referencyjna}}}}, przy których znajduje się ich opis, podanych przy jego parametrach. Nagłówek strony jest tworzony z: {{Code|strona}} i {{Code|podstrona}}, także na podstawie parametru {{Code|czy_pod_ustep}}, gdy magłówek jest pusty, on jesty wyznaczany z: {{Code|pelnanazwajednostki}}, a później jest do tego wykorzystywana zmienna: {{Code|czy_pod_ustep}}, do liczenia właściwego nagłówka. Parametr nazwy linku jest w zmiennej {{Code|nazwa}}, a jezeli ona nie istnieje, wtedy wykorzystujemy do tego element {{Code|strona}}, do którego wykorzystywana jest w: {{Code|{{sr|#p.Indentyfikator_lub_podstrona_wikiadresu_strony()|p=Sekcja referencyjna}}}}, która nie zawsze musi modyfikować tą zmiennej. Funkcja {{Code|{{sr|#p.Nazwa_od_niewielkiej_lub_wielkiej_litery()|p=Sekcja referencyjna}}}} ustala odpowiednio zmodyfikowaną nazwę, według zmiennych, które powinny być niesprzeczne, chodzi tu o: {{Code|od_malej}} i {{Code|od_duzej}}, w przeciwnym wypadku lub jeżeli one nie są ustawione, wtedy nazwa linku pozostaje niezmieniona. Funkcja zwraca trzy parametry jednocześnie, czyli nazwę strony, jego nagłówek i nazwę linku. == {{Code|p.Wolumin()}} == Funkcja tworzy link do podnego artykułu podręcznika, ewentualnie z nazwą nagłówka. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Wolumin(strona,podstrona,nazwa,czy_ustep,od_malej,od_duzej,pelnanazwajednostki)...end; </syntaxhighlight> Wartości opcjonalne powyżej przyjmują wartość {{Code|nil}}, wtedy możemy je uznać tak, jak by je, nie podaliśmy. Funkcja przyjmuje parametry podane w tym rozdziale w parametrach tej funkcji, w jego definicji skrótowej, według zmiennych podanych w parametrach zdefiniowanych jako w punkcie dla funkcji {{Code|{{sr|#p["Sekcja referencyjna"](frame)|p=Sekcja referencyjna}}}}, przy których znajduje się ich opis, podanych przy jego parametrach. Jeżeli parametr {{Code|strona}} nie istnieje, to ona jest tworzona na podstawie {{Code|pelnanazwajednostki}}, nie używajac parametru {{Code|podstrona}}. A jeżeli on istnieje, to nowa wartość {{Code|strona}} jest tworzona ze starego {{Code|strona}} i {{Code|podstrona}}. Funkcja zwraca dwa parametry jednocześnie, czyli policzoną nazwę strony, policzonej z parametru {{Code|strona}},ewentualnie {{Code|podstrona}} i nazwę linku z {{Code|nazwa}}, a jeżeli ona nie istnieje to ona jest tworzona z: {{Code|strona}}, wykorzystując funkcję {{Code|{{sr|#p.Indentyfikator_lub_podstrona_wikiadresu_strony()|p=Sekcja referencyjna}}}}. == {{Code|p["Sekcja referencyjna"](frame)}} == Szablon linków inteligentnych z kodami na stronie {{s|Link wewnętrzny}}, który się mieści w tabeli wywołania szablonowego {{s|Tabela nawigacyjna}}, linkujący się do stron tego samego podręcznika, w której został wywołany, ewentualnie do jego identyfikatora danego elementu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Sekcja referencyjna"]=function(frame)...end; </syntaxhighlight> Parametrami tablicy ramki modułu, które są podane w rodzicu w szablonie lub w samej ramce, jeżeli jest podany parametr {{Parametr|wyspecjalizowana|tak}} w samej ramce, a one są: * {{Code|1}}, {{Code|s}} lub {{Code|strona}} - jest to artykuł w podręczniku, ewentualnie z nagłówkiem, zdefiniujmy go jako: {{Code|strona}}, * {{Code|2}}, {{Code|n}} lub {{Code|nazwa}} - nazwa linku wyświetlana w artykule, zdefiniujmy go jako: {{Code|nazwa}}, * {{Code|3}}, {{Code|p}} lub {{Code|podstrona}} - podstrona dodawana do linku podczas rozważać, wtedy artykuł, będzie o jeden lub wyżej, głębiej w drzewie danej przestrzeni nazw, zdefiniujmy go jako: {{Code|podstrona}}, * {{Code|4}}. {{Code|u}} lub {{Code|ustęp}} - jeśli przyjmuje wartość niepustą, to nazwa wyświetlana linku jest jego nagłówek, jeżeli istnieje, lub jego podstrona albo sama strona, w przypadku przestrzeni nazw {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}} oraz nibyprzestrzeni nazw {{lr2|Brudnopis}}, w przestrzeni nazw {{Np|Project|link=tak}}, a także przestrzeni użytkownika {{Np|User|link=tak}}, a w przypadku nie podania nazwy strony {{Code|strona}} (lub jego skrót: {{Code|s}}) lub {{Code|1}}, to parametr {{Code|ustęp}} zachowuje się odwrotnie, wtedy nazwę strony, do której linkuje szablon, przyjmujemy domyślnie, że jest to nazwa książki, w przestrzeniach nazw w dwóch pierwszych nie widać różnicy działania tego parametru, już jest różnica w nibyprzestrzeniach nazw dwóch ostatnich, tutaj ten szablon podaje subnazwę książki, a nie jego adres, gdzie przy {{Parametr|ustęp|tak}} (lub jego synonim numerowany: {{Parametr|4|tak}}) (lub jego skrót: {{Parametr|u|tak}}) podaje cały adres, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|czy_ustęp}}, * {{Code|m}}, {{Code|od małej}} - jeśli niepuste, wyświetlany jest link od małej litery, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|od malej}}, * {{Code|d}}, {{Code|od dużej}} - jeśli niepuste, wyświetlany jest link od dużej litery, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|od dużej}}, * {{Code|t}}, {{Code|pod-ustęp}} - na stronach zbiorczych skraca nazwę nagłówka, która na stronie artykułów podręcznika byłaby nazwą strony, do substrony, zdefiujmy go jako: {{Code|czy_pod_ustep}}. ---- W tej funkcji jeszcze jest liczona zmienna: {{Code|pelnanazwajednostki}}, oznaczająca: pełna nazwa jednostki uzyskana jest, dzięki podanym zmiennym pudełkowym {{m|Pudełko}}, czyli według: {{Code|nazwa przestrzeni nazw}} i {{Code|nazwa jednostki}}, a jeżeli jakaś z tych zmiennych nie została podana, to traktowana jest, jakby była podana, w takim razie te niepodane są liczona na podstawie parametrów aktualnej strony, a jeśli są niepodane, wtedy jest sprawdzane jedynie ich nieistnienie, na podstawie tego wszystkiego jest liczona pełna nazwa jednostki, przy pomocy funkcji: {{sr|#p["Pełna nazwa jednostki"](frame,...)|p=Pudełko/Tom II}}, z tej zmiennej jest liczona pełna nazwa książki, używając funkcji: {{sr|#m["PEŁNANAZWAKSIĄŻKI"]()|p=Nazwy/Tom IV}} w funkcjach: {{Code|{{sr|#p.Strona_zbiorcza()|p=Sekcja referencyjna}}}} i {{Code|{{sr|#p.Wolumin()|p=Sekcja referencyjna}}}}, parametry pudełek mogą wskazywać na inny artykuł niż aktualny, ale tak nie musi być, byle tylko adres książki się zgadzał z tą aktualną, przy nie podaniu parametrów przestrzennych i jednostki, a z nimi adres woluminy może być inny. ---- Te parametry powyżej są jednocześnie parametrami szablonu {{s|Sekcja referencyjna}} (lub jego wersji skrótowej {{s|sr}}). Te parametry możemy podać też w formie funkcyjnej: <syntaxhighlight lang="lua"> local sekcja_referencyjna_modul=require("Module:Sekcja referencyjna"); local link=sekcja_referencyjna_modul["Sekcja referencyjna"]{args={strona=..., nazwa=.., podstrona=..., ...}}; </syntaxhighlight> W ramce funkcyjnej parametry ze znakami nienależącymi do alfabetu łacińskiego piszmy w cudzysłowach w nawiasach kwadratowych, czyli w formie: {{Code|["pod-ustęp"]{{=}}...}}, czy parametry numerowe w nawiasach bez cudzysłowu: {{Code|[1]{{=}}...}}, a parametry normalne piszemy: {{Code|strona{{=}}...}}. Funkcja w uruchamianiu ma dwa warianty, na normalnej stronie niezbiorczej uruchamiana jest funkcja {{Code|{{sr|#p.Wolumin()|p=Sekcja referencyjna}}}}, a na jakikolwiek stronie zbiorczej według Stronicowego Parsera na podstawie modułu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli strony zefiniowanej w: {{Code|{{m|StronicowyParser/StronaSubst}}}}, jest uruchamiana funkcja: {{Code|{{sr|#p.Strona_zbiorcza()|p=Sekcja referencyjna}}}} (a ta przedostatnia jest uruchamiana przez funkcję: {{Code|{{m|StronicowyParser|CzyStronaSubst}}}}, która zwraca wynik {{Code|tak}}, gdy strona dana jest bieżąca lub podana na podstawie parametrów pudełkowych: {{Code|{{m|Pudełko}}}}, która jest stroną zbiorczą, w przeciwnym wypadku mamy wynik: {{Code|nil}}, gdy nie). {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 9liu2n9i7ge8pnudts37kcgi4f23cue 541366 541365 2026-04-30T11:14:55Z Persino 2851 /* {{Code|p["Sekcja referencyjna"](frame)}} */ 541366 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Sekcja referencyjna}}|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 sekcja_referencyjna_modul=require("Module:Sekcja referencyjna"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Ta funkcja o nazwie: {{Code|{{sr|#p["Sekcja referencyjna"]()|p=Sekcja referencyjna}}}}, jak i szablon: {{Code|{{s|Sekcja referencyjna}}}} (lub jego wersja skrótowa: {{Code|{{s|sr}}}} - w postaci przekierowania do jego dłuższej wersji), służy do wyświetlania na normalnej lub stronie zbiorczej linków inteligentnych danego podręcznika, jeżeli podamy jego artykuł wraz z, lub bez, nagłówka, lub nagłówek z hashem, z artykułem w zmiennej w: {{Code|podstrona}} (lub ten parametr podany w wersji skrótowej {{Code|p}}), też można linkować do strony głównej podręcznika, nie podając żadnego artykułu w funkcji w: {{sr|#p["Sekcja referencyjna"]()|p=Sekcja referencyjna}}, w zmiennej: {{Code|strona}} (lub w wersji jego skrótowej {{Code|s}}), i w zmiennej w jego pierwszym parametrze numerowanym, lub w jego wersji szablonowej. Ta funkcja lub jego odpowiednik szablonowy wyświetla na stronie normalnej artykułu link do artykułu, a na stronie zbiorczej link do identyfikatora jakiegoś obiektu na stronie. Inne funkcje użyte w module: {{Code|{{ld2|Sekcja referencyjna}}}}, są funkcjami pomocniczymi do głównej jego funkcji, która służy do wywołania w ramce w jego odpowiedniku szablonowym, podany tutaj na samym początku tej strony, te funkcje służą też do użycia w innych modułach, np.: {{ld2|StronicowyParser/Potrzebne}}. Funkcje tutaj opisują obsługę linków inteligentnych (tzw. linki inteligentne), który koloruje linki w zależności do jakiej kategorii szablon zaliczy stronę wskazaną w nim. Zestaw możliwych kodów linkowych, znajduje się na stronie {{s|Link wewnętrzny}}, w miejscu pod tabelą nawigacyjną {{s|Tabela nawigacyjna}}, według jego wikikodu opisu. === Dlaczego te funkcje w opisywanym module, jak i szablon, o który jest zdefiniowany === Moduł {{ld2|Sekcja referencyjna}}, i też szablon {{s|Sekcja referencyjna}} (używany w postaci przekierowania do niego {{s|sr}}), który wykorzystuje ten moduł do swojej definicji, zostały stworzone do używania w spisach treści, oraz wewnątrz zwyczajnych stron książki jako odnośnik do sekcji (rozdziału/podrozdziału/itp.). Ideą tego modułu (szablonu) było rozwiązanie pewnego problemu pojawiającego się, gdy strona zostanie wydrukowana w formie PDF-a, ale nie na papier. Normalnie, gdy spis treści zawiera linki do rozdziałów tworzonych normalnym sposobem (przez wikilinki), to w wydrukowanej formie te linki zostają odnośnikami bezwzględnymi do strony Wikibooks. Gdy użytkownik kliknie w taki link w PDF-ie, to zostanie przekierowany do przeglądarki WWW z otwartą stroną Wikibooks. Psuje to użytkowanie takiej strony, gdyż użytkownik zazwyczaj zakłada, że gdy kliknie na odnośnik w spisie treści, to ten przeniesie go na odpowiednią stronę ''wewnątrz'' PDF-a. Ten moduł (szablon) rozwiązuje ten problem, przez warunkową zamianę linków do stron sekcji w linki lokalne do sekcji wewnątrz strony do druku. W niektórych generatorach PDF-a taka zamiana skutkuje tym, że takie linki umieszczone w spisach treści, powodują przeniesienie do odpowiedniej strony, a nie przeskok do strony WWW (pozostałe generatory po prostu nie generują linków w ogóle). == {{Code|p.Indentyfikator_lub_podstrona_wikiadresu_strony()}} == Funkcja zwraca nagłówek strony, jeżeli istnieje, lub jego podstronę, a jeżeli ona nie ma żadnej podstrony według tego adresu, to cały ten adres, który nie jest adresem {{Strong|HTML}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Indentyfikator_lub_podstrona_wikiadresu_strony(ustep,czy_ustep)...end; </syntaxhighlight> Parametry funkcji: * {{Code|ustep}} - nazwa strony ustępu strony, co z niego robimy nazwę linku, * {{Code|czy_ustep}} - jeżeli {{Code|true}} liczy wtedy nagłówek, a jeżeli tego nie ma to podstronę. Jeżeli {{Code|ustep{{=}}nil}}, w takim razie jest zwracana wartość parametru tego, czyli {{Code|nil}}. Aby nie uzyskać identyfikatora strony, to drugi parametr, czyli {{Code|czy_ustep}}, nie może przyjmować wartości logicznej {{Code|true}}, tylko jako {{Code|false}} lub {{Code|nil}} - wtedy zwracana jest wartość argumentu {{Code|ustęp}}. A jeżeli podamy wartość {{Code|true}}, gdy zmienna {{Code|ustep}} zawiera nagłówek, to zwracany jest właśnie on bez znaku {{Code|#}}, a jeżeli nie zawiera on tego, tylko podstronę, wtedy zwracana jest jego podstrona. W przeciwny wypadku zwracana jest sama wartość argumentu {{Code|ustep}}. == {{Code|p.Nazwa_od_niewielkiej_lub_wielkiej_litery()}} == Funkcja zamienia w nazwie linku pierwszy znak, który jest od litery, aby był od dużej lub małej litery, w zależności od parametrów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwa_od_niewielkiej_lub_wielkiej_litery(nazwa,od_malej,od_duzej)...end; </syntaxhighlight> Parametry funkcji: * {{Code|nazwa}} - nazwa linku strony, * {{Code|od malej}} - zamienia pierwszą literę, pierwszy znak, nazwy linku na małą literę, * {{Code|od dużej}} - zamienia pierwszą literę, pierwszy znak, nazwy linku na dużą literę. Te parametry nie mogą się zaprzeczać między sobą, tzn. oba ostatnie parametry nie mogą być nie {{Code|true}}. W przeciwny wypadku funkcja zwraca samą nieprzekształconą nazwę strony. == {{Code|p.Strona_zbiorcza()}} == Funkcja tworzy link na stronie zbiorczej sama do siebie do elementu wskazywanego przez stworzony nagłówek z parametrów tej funkcji. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Strona_zbiorcza(strona,podstrona,nazwa,czy_ustep,czy_pod_ustep,od_malej,od_duzej,pelnanazwajednostki)...end; </syntaxhighlight> Wartości opcjonalne powyżej przyjmują wartość {{Code|nil}}, wtedy możemy je uznać tak, jak by je, nie podaliśmy. Funkcja przyjmuje parametry podane w tym rozdziale w parametrach tej funkcji, w jego definicji skrótowej, według zmiennych podanych w parametrach zdefiniowanych jako w punkcie dla funkcji {{Code|{{sr|#p["Sekcja referencyjna"](frame)|p=Sekcja referencyjna}}}}, przy których znajduje się ich opis, podanych przy jego parametrach. Nagłówek strony jest tworzony z: {{Code|strona}} i {{Code|podstrona}}, także na podstawie parametru {{Code|czy_pod_ustep}}, gdy magłówek jest pusty, on jesty wyznaczany z: {{Code|pelnanazwajednostki}}, a później jest do tego wykorzystywana zmienna: {{Code|czy_pod_ustep}}, do liczenia właściwego nagłówka. Parametr nazwy linku jest w zmiennej {{Code|nazwa}}, a jezeli ona nie istnieje, wtedy wykorzystujemy do tego element {{Code|strona}}, do którego wykorzystywana jest w: {{Code|{{sr|#p.Indentyfikator_lub_podstrona_wikiadresu_strony()|p=Sekcja referencyjna}}}}, która nie zawsze musi modyfikować tą zmiennej. Funkcja {{Code|{{sr|#p.Nazwa_od_niewielkiej_lub_wielkiej_litery()|p=Sekcja referencyjna}}}} ustala odpowiednio zmodyfikowaną nazwę, według zmiennych, które powinny być niesprzeczne, chodzi tu o: {{Code|od_malej}} i {{Code|od_duzej}}, w przeciwnym wypadku lub jeżeli one nie są ustawione, wtedy nazwa linku pozostaje niezmieniona. Funkcja zwraca trzy parametry jednocześnie, czyli nazwę strony, jego nagłówek i nazwę linku. == {{Code|p.Wolumin()}} == Funkcja tworzy link do podnego artykułu podręcznika, ewentualnie z nazwą nagłówka. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Wolumin(strona,podstrona,nazwa,czy_ustep,od_malej,od_duzej,pelnanazwajednostki)...end; </syntaxhighlight> Wartości opcjonalne powyżej przyjmują wartość {{Code|nil}}, wtedy możemy je uznać tak, jak by je, nie podaliśmy. Funkcja przyjmuje parametry podane w tym rozdziale w parametrach tej funkcji, w jego definicji skrótowej, według zmiennych podanych w parametrach zdefiniowanych jako w punkcie dla funkcji {{Code|{{sr|#p["Sekcja referencyjna"](frame)|p=Sekcja referencyjna}}}}, przy których znajduje się ich opis, podanych przy jego parametrach. Jeżeli parametr {{Code|strona}} nie istnieje, to ona jest tworzona na podstawie {{Code|pelnanazwajednostki}}, nie używajac parametru {{Code|podstrona}}. A jeżeli on istnieje, to nowa wartość {{Code|strona}} jest tworzona ze starego {{Code|strona}} i {{Code|podstrona}}. Funkcja zwraca dwa parametry jednocześnie, czyli policzoną nazwę strony, policzonej z parametru {{Code|strona}},ewentualnie {{Code|podstrona}} i nazwę linku z {{Code|nazwa}}, a jeżeli ona nie istnieje to ona jest tworzona z: {{Code|strona}}, wykorzystując funkcję {{Code|{{sr|#p.Indentyfikator_lub_podstrona_wikiadresu_strony()|p=Sekcja referencyjna}}}}. == {{Code|p["Sekcja referencyjna"](frame)}} == Szablon linków inteligentnych z kodami na stronie {{s|Link wewnętrzny}}, który się mieści w tabeli wywołania szablonowego {{s|Tabela nawigacyjna}} w jego parametrze, tam są też linkujące do tej samej strony, czyli do szablonu arkusza stylów, w której został wywołany, ewentualnie do jego identyfikatora danego elementu, mający kolory odpowiednie dla nich, a właściwe wartości kodów znajdują się w znaczniku szablonowym {{s|span}} obok tych odpowiednich elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Sekcja referencyjna"]=function(frame)...end; </syntaxhighlight> Parametrami tablicy ramki modułu, które są podane w rodzicu w szablonie lub w samej ramce, jeżeli jest podany parametr {{Parametr|wyspecjalizowana|tak}} w samej ramce, a one są: * {{Code|1}}, {{Code|s}} lub {{Code|strona}} - jest to artykuł w podręczniku, ewentualnie z nagłówkiem, zdefiniujmy go jako: {{Code|strona}}, * {{Code|2}}, {{Code|n}} lub {{Code|nazwa}} - nazwa linku wyświetlana w artykule, zdefiniujmy go jako: {{Code|nazwa}}, * {{Code|3}}, {{Code|p}} lub {{Code|podstrona}} - podstrona dodawana do linku podczas rozważać, wtedy artykuł, będzie o jeden lub wyżej, głębiej w drzewie danej przestrzeni nazw, zdefiniujmy go jako: {{Code|podstrona}}, * {{Code|4}}. {{Code|u}} lub {{Code|ustęp}} - jeśli przyjmuje wartość niepustą, to nazwa wyświetlana linku jest jego nagłówek, jeżeli istnieje, lub jego podstrona albo sama strona, w przypadku przestrzeni nazw {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}} oraz nibyprzestrzeni nazw {{lr2|Brudnopis}}, w przestrzeni nazw {{Np|Project|link=tak}}, a także przestrzeni użytkownika {{Np|User|link=tak}}, a w przypadku nie podania nazwy strony {{Code|strona}} (lub jego skrót: {{Code|s}}) lub {{Code|1}}, to parametr {{Code|ustęp}} zachowuje się odwrotnie, wtedy nazwę strony, do której linkuje szablon, przyjmujemy domyślnie, że jest to nazwa książki, w przestrzeniach nazw w dwóch pierwszych nie widać różnicy działania tego parametru, już jest różnica w nibyprzestrzeniach nazw dwóch ostatnich, tutaj ten szablon podaje subnazwę książki, a nie jego adres, gdzie przy {{Parametr|ustęp|tak}} (lub jego synonim numerowany: {{Parametr|4|tak}}) (lub jego skrót: {{Parametr|u|tak}}) podaje cały adres, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|czy_ustęp}}, * {{Code|m}}, {{Code|od małej}} - jeśli niepuste, wyświetlany jest link od małej litery, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|od malej}}, * {{Code|d}}, {{Code|od dużej}} - jeśli niepuste, wyświetlany jest link od dużej litery, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|od dużej}}, * {{Code|t}}, {{Code|pod-ustęp}} - na stronach zbiorczych skraca nazwę nagłówka, która na stronie artykułów podręcznika byłaby nazwą strony, do substrony, zdefiujmy go jako: {{Code|czy_pod_ustep}}. ---- W tej funkcji jeszcze jest liczona zmienna: {{Code|pelnanazwajednostki}}, oznaczająca: pełna nazwa jednostki uzyskana jest, dzięki podanym zmiennym pudełkowym {{m|Pudełko}}, czyli według: {{Code|nazwa przestrzeni nazw}} i {{Code|nazwa jednostki}}, a jeżeli jakaś z tych zmiennych nie została podana, to traktowana jest, jakby była podana, w takim razie te niepodane są liczona na podstawie parametrów aktualnej strony, a jeśli są niepodane, wtedy jest sprawdzane jedynie ich nieistnienie, na podstawie tego wszystkiego jest liczona pełna nazwa jednostki, przy pomocy funkcji: {{sr|#p["Pełna nazwa jednostki"](frame,...)|p=Pudełko/Tom II}}, z tej zmiennej jest liczona pełna nazwa książki, używając funkcji: {{sr|#m["PEŁNANAZWAKSIĄŻKI"]()|p=Nazwy/Tom IV}} w funkcjach: {{Code|{{sr|#p.Strona_zbiorcza()|p=Sekcja referencyjna}}}} i {{Code|{{sr|#p.Wolumin()|p=Sekcja referencyjna}}}}, parametry pudełek mogą wskazywać na inny artykuł niż aktualny, ale tak nie musi być, byle tylko adres książki się zgadzał z tą aktualną, przy nie podaniu parametrów przestrzennych i jednostki, a z nimi adres woluminy może być inny. ---- Te parametry powyżej są jednocześnie parametrami szablonu {{s|Sekcja referencyjna}} (lub jego wersji skrótowej {{s|sr}}). Te parametry możemy podać też w formie funkcyjnej: <syntaxhighlight lang="lua"> local sekcja_referencyjna_modul=require("Module:Sekcja referencyjna"); local link=sekcja_referencyjna_modul["Sekcja referencyjna"]{args={strona=..., nazwa=.., podstrona=..., ...}}; </syntaxhighlight> W ramce funkcyjnej parametry ze znakami nienależącymi do alfabetu łacińskiego piszmy w cudzysłowach w nawiasach kwadratowych, czyli w formie: {{Code|["pod-ustęp"]{{=}}...}}, czy parametry numerowe w nawiasach bez cudzysłowu: {{Code|[1]{{=}}...}}, a parametry normalne piszemy: {{Code|strona{{=}}...}}. Funkcja w uruchamianiu ma dwa warianty, na normalnej stronie niezbiorczej uruchamiana jest funkcja {{Code|{{sr|#p.Wolumin()|p=Sekcja referencyjna}}}}, a na jakikolwiek stronie zbiorczej według Stronicowego Parsera na podstawie modułu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli strony zefiniowanej w: {{Code|{{m|StronicowyParser/StronaSubst}}}}, jest uruchamiana funkcja: {{Code|{{sr|#p.Strona_zbiorcza()|p=Sekcja referencyjna}}}} (a ta przedostatnia jest uruchamiana przez funkcję: {{Code|{{m|StronicowyParser|CzyStronaSubst}}}}, która zwraca wynik {{Code|tak}}, gdy strona dana jest bieżąca lub podana na podstawie parametrów pudełkowych: {{Code|{{m|Pudełko}}}}, która jest stroną zbiorczą, w przeciwnym wypadku mamy wynik: {{Code|nil}}, gdy nie). {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 9hvvqmv9zbtn4k5qewnktgi0mw5j9cr 541370 541366 2026-04-30T11:32:18Z Persino 2851 /* {{Code|p["Sekcja referencyjna"](frame)}} */ 541370 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Sekcja referencyjna}}|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 sekcja_referencyjna_modul=require("Module:Sekcja referencyjna"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Ta funkcja o nazwie: {{Code|{{sr|#p["Sekcja referencyjna"]()|p=Sekcja referencyjna}}}}, jak i szablon: {{Code|{{s|Sekcja referencyjna}}}} (lub jego wersja skrótowa: {{Code|{{s|sr}}}} - w postaci przekierowania do jego dłuższej wersji), służy do wyświetlania na normalnej lub stronie zbiorczej linków inteligentnych danego podręcznika, jeżeli podamy jego artykuł wraz z, lub bez, nagłówka, lub nagłówek z hashem, z artykułem w zmiennej w: {{Code|podstrona}} (lub ten parametr podany w wersji skrótowej {{Code|p}}), też można linkować do strony głównej podręcznika, nie podając żadnego artykułu w funkcji w: {{sr|#p["Sekcja referencyjna"]()|p=Sekcja referencyjna}}, w zmiennej: {{Code|strona}} (lub w wersji jego skrótowej {{Code|s}}), i w zmiennej w jego pierwszym parametrze numerowanym, lub w jego wersji szablonowej. Ta funkcja lub jego odpowiednik szablonowy wyświetla na stronie normalnej artykułu link do artykułu, a na stronie zbiorczej link do identyfikatora jakiegoś obiektu na stronie. Inne funkcje użyte w module: {{Code|{{ld2|Sekcja referencyjna}}}}, są funkcjami pomocniczymi do głównej jego funkcji, która służy do wywołania w ramce w jego odpowiedniku szablonowym, podany tutaj na samym początku tej strony, te funkcje służą też do użycia w innych modułach, np.: {{ld2|StronicowyParser/Potrzebne}}. Funkcje tutaj opisują obsługę linków inteligentnych (tzw. linki inteligentne), który koloruje linki w zależności do jakiej kategorii szablon zaliczy stronę wskazaną w nim. Zestaw możliwych kodów linkowych, znajduje się na stronie {{s|Link wewnętrzny}}, w miejscu pod tabelą nawigacyjną {{s|Tabela nawigacyjna}}, według jego wikikodu opisu. === Dlaczego te funkcje w opisywanym module, jak i szablon, o który jest zdefiniowany === Moduł {{ld2|Sekcja referencyjna}}, i też szablon {{s|Sekcja referencyjna}} (używany w postaci przekierowania do niego {{s|sr}}), który wykorzystuje ten moduł do swojej definicji, zostały stworzone do używania w spisach treści, oraz wewnątrz zwyczajnych stron książki jako odnośnik do sekcji (rozdziału/podrozdziału/itp.). Ideą tego modułu (szablonu) było rozwiązanie pewnego problemu pojawiającego się, gdy strona zostanie wydrukowana w formie PDF-a, ale nie na papier. Normalnie, gdy spis treści zawiera linki do rozdziałów tworzonych normalnym sposobem (przez wikilinki), to w wydrukowanej formie te linki zostają odnośnikami bezwzględnymi do strony Wikibooks. Gdy użytkownik kliknie w taki link w PDF-ie, to zostanie przekierowany do przeglądarki WWW z otwartą stroną Wikibooks. Psuje to użytkowanie takiej strony, gdyż użytkownik zazwyczaj zakłada, że gdy kliknie na odnośnik w spisie treści, to ten przeniesie go na odpowiednią stronę ''wewnątrz'' PDF-a. Ten moduł (szablon) rozwiązuje ten problem, przez warunkową zamianę linków do stron sekcji w linki lokalne do sekcji wewnątrz strony do druku. W niektórych generatorach PDF-a taka zamiana skutkuje tym, że takie linki umieszczone w spisach treści, powodują przeniesienie do odpowiedniej strony, a nie przeskok do strony WWW (pozostałe generatory po prostu nie generują linków w ogóle). == {{Code|p.Indentyfikator_lub_podstrona_wikiadresu_strony()}} == Funkcja zwraca nagłówek strony, jeżeli istnieje, lub jego podstronę, a jeżeli ona nie ma żadnej podstrony według tego adresu, to cały ten adres, który nie jest adresem {{Strong|HTML}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Indentyfikator_lub_podstrona_wikiadresu_strony(ustep,czy_ustep)...end; </syntaxhighlight> Parametry funkcji: * {{Code|ustep}} - nazwa strony ustępu strony, co z niego robimy nazwę linku, * {{Code|czy_ustep}} - jeżeli {{Code|true}} liczy wtedy nagłówek, a jeżeli tego nie ma to podstronę. Jeżeli {{Code|ustep{{=}}nil}}, w takim razie jest zwracana wartość parametru tego, czyli {{Code|nil}}. Aby nie uzyskać identyfikatora strony, to drugi parametr, czyli {{Code|czy_ustep}}, nie może przyjmować wartości logicznej {{Code|true}}, tylko jako {{Code|false}} lub {{Code|nil}} - wtedy zwracana jest wartość argumentu {{Code|ustęp}}. A jeżeli podamy wartość {{Code|true}}, gdy zmienna {{Code|ustep}} zawiera nagłówek, to zwracany jest właśnie on bez znaku {{Code|#}}, a jeżeli nie zawiera on tego, tylko podstronę, wtedy zwracana jest jego podstrona. W przeciwny wypadku zwracana jest sama wartość argumentu {{Code|ustep}}. == {{Code|p.Nazwa_od_niewielkiej_lub_wielkiej_litery()}} == Funkcja zamienia w nazwie linku pierwszy znak, który jest od litery, aby był od dużej lub małej litery, w zależności od parametrów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwa_od_niewielkiej_lub_wielkiej_litery(nazwa,od_malej,od_duzej)...end; </syntaxhighlight> Parametry funkcji: * {{Code|nazwa}} - nazwa linku strony, * {{Code|od malej}} - zamienia pierwszą literę, pierwszy znak, nazwy linku na małą literę, * {{Code|od dużej}} - zamienia pierwszą literę, pierwszy znak, nazwy linku na dużą literę. Te parametry nie mogą się zaprzeczać między sobą, tzn. oba ostatnie parametry nie mogą być nie {{Code|true}}. W przeciwny wypadku funkcja zwraca samą nieprzekształconą nazwę strony. == {{Code|p.Strona_zbiorcza()}} == Funkcja tworzy link na stronie zbiorczej sama do siebie do elementu wskazywanego przez stworzony nagłówek z parametrów tej funkcji. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Strona_zbiorcza(strona,podstrona,nazwa,czy_ustep,czy_pod_ustep,od_malej,od_duzej,pelnanazwajednostki)...end; </syntaxhighlight> Wartości opcjonalne powyżej przyjmują wartość {{Code|nil}}, wtedy możemy je uznać tak, jak by je, nie podaliśmy. Funkcja przyjmuje parametry podane w tym rozdziale w parametrach tej funkcji, w jego definicji skrótowej, według zmiennych podanych w parametrach zdefiniowanych jako w punkcie dla funkcji {{Code|{{sr|#p["Sekcja referencyjna"](frame)|p=Sekcja referencyjna}}}}, przy których znajduje się ich opis, podanych przy jego parametrach. Nagłówek strony jest tworzony z: {{Code|strona}} i {{Code|podstrona}}, także na podstawie parametru {{Code|czy_pod_ustep}}, gdy magłówek jest pusty, on jesty wyznaczany z: {{Code|pelnanazwajednostki}}, a później jest do tego wykorzystywana zmienna: {{Code|czy_pod_ustep}}, do liczenia właściwego nagłówka. Parametr nazwy linku jest w zmiennej {{Code|nazwa}}, a jezeli ona nie istnieje, wtedy wykorzystujemy do tego element {{Code|strona}}, do którego wykorzystywana jest w: {{Code|{{sr|#p.Indentyfikator_lub_podstrona_wikiadresu_strony()|p=Sekcja referencyjna}}}}, która nie zawsze musi modyfikować tą zmiennej. Funkcja {{Code|{{sr|#p.Nazwa_od_niewielkiej_lub_wielkiej_litery()|p=Sekcja referencyjna}}}} ustala odpowiednio zmodyfikowaną nazwę, według zmiennych, które powinny być niesprzeczne, chodzi tu o: {{Code|od_malej}} i {{Code|od_duzej}}, w przeciwnym wypadku lub jeżeli one nie są ustawione, wtedy nazwa linku pozostaje niezmieniona. Funkcja zwraca trzy parametry jednocześnie, czyli nazwę strony, jego nagłówek i nazwę linku. == {{Code|p.Wolumin()}} == Funkcja tworzy link do podnego artykułu podręcznika, ewentualnie z nazwą nagłówka. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Wolumin(strona,podstrona,nazwa,czy_ustep,od_malej,od_duzej,pelnanazwajednostki)...end; </syntaxhighlight> Wartości opcjonalne powyżej przyjmują wartość {{Code|nil}}, wtedy możemy je uznać tak, jak by je, nie podaliśmy. Funkcja przyjmuje parametry podane w tym rozdziale w parametrach tej funkcji, w jego definicji skrótowej, według zmiennych podanych w parametrach zdefiniowanych jako w punkcie dla funkcji {{Code|{{sr|#p["Sekcja referencyjna"](frame)|p=Sekcja referencyjna}}}}, przy których znajduje się ich opis, podanych przy jego parametrach. Jeżeli parametr {{Code|strona}} nie istnieje, to ona jest tworzona na podstawie {{Code|pelnanazwajednostki}}, nie używajac parametru {{Code|podstrona}}. A jeżeli on istnieje, to nowa wartość {{Code|strona}} jest tworzona ze starego {{Code|strona}} i {{Code|podstrona}}. Funkcja zwraca dwa parametry jednocześnie, czyli policzoną nazwę strony, policzonej z parametru {{Code|strona}},ewentualnie {{Code|podstrona}} i nazwę linku z {{Code|nazwa}}, a jeżeli ona nie istnieje to ona jest tworzona z: {{Code|strona}}, wykorzystując funkcję {{Code|{{sr|#p.Indentyfikator_lub_podstrona_wikiadresu_strony()|p=Sekcja referencyjna}}}}. == {{Code|p["Sekcja referencyjna"](frame)}} == Szablon linków inteligentnych z kodami na stronie {{s|Link wewnętrzny}}, który się mieści w tabeli wywołania szablonowego {{s|Tabela nawigacyjna}} w jego parametrze, tam są też linkujące do tej samej strony, czyli do szablonu arkusza stylów, w której został wywołany, ewentualnie do jego identyfikatora danego elementu, mające kolory odpowiednie dla nich, a właściwe wartości kodów znajdują się w znaczniku szablonowym {{s|span}} obok tych odpowiednich elementów. Funkcja koloruje linki w zależności do jakiej kategorii on należy, a do tego celu używa {{NAZWASERWISU|klucz projektu=d|link=tak}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Sekcja referencyjna"]=function(frame)...end; </syntaxhighlight> Parametrami tablicy ramki modułu, które są podane w rodzicu w szablonie lub w samej ramce, jeżeli jest podany parametr {{Parametr|wyspecjalizowana|tak}} w samej ramce, a one są: * {{Code|1}}, {{Code|s}} lub {{Code|strona}} - jest to artykuł w podręczniku, ewentualnie z nagłówkiem, zdefiniujmy go jako: {{Code|strona}}, * {{Code|2}}, {{Code|n}} lub {{Code|nazwa}} - nazwa linku wyświetlana w artykule, zdefiniujmy go jako: {{Code|nazwa}}, * {{Code|3}}, {{Code|p}} lub {{Code|podstrona}} - podstrona dodawana do linku podczas rozważać, wtedy artykuł, będzie o jeden lub wyżej, głębiej w drzewie danej przestrzeni nazw, zdefiniujmy go jako: {{Code|podstrona}}, * {{Code|4}}. {{Code|u}} lub {{Code|ustęp}} - jeśli przyjmuje wartość niepustą, to nazwa wyświetlana linku jest jego nagłówek, jeżeli istnieje, lub jego podstrona albo sama strona, w przypadku przestrzeni nazw {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}} oraz nibyprzestrzeni nazw {{lr2|Brudnopis}}, w przestrzeni nazw {{Np|Project|link=tak}}, a także przestrzeni użytkownika {{Np|User|link=tak}}, a w przypadku nie podania nazwy strony {{Code|strona}} (lub jego skrót: {{Code|s}}) lub {{Code|1}}, to parametr {{Code|ustęp}} zachowuje się odwrotnie, wtedy nazwę strony, do której linkuje szablon, przyjmujemy domyślnie, że jest to nazwa książki, w przestrzeniach nazw w dwóch pierwszych nie widać różnicy działania tego parametru, już jest różnica w nibyprzestrzeniach nazw dwóch ostatnich, tutaj ten szablon podaje subnazwę książki, a nie jego adres, gdzie przy {{Parametr|ustęp|tak}} (lub jego synonim numerowany: {{Parametr|4|tak}}) (lub jego skrót: {{Parametr|u|tak}}) podaje cały adres, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|czy_ustęp}}, * {{Code|m}}, {{Code|od małej}} - jeśli niepuste, wyświetlany jest link od małej litery, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|od malej}}, * {{Code|d}}, {{Code|od dużej}} - jeśli niepuste, wyświetlany jest link od dużej litery, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|od dużej}}, * {{Code|t}}, {{Code|pod-ustęp}} - na stronach zbiorczych skraca nazwę nagłówka, która na stronie artykułów podręcznika byłaby nazwą strony, do substrony, zdefiujmy go jako: {{Code|czy_pod_ustep}}. ---- W tej funkcji jeszcze jest liczona zmienna: {{Code|pelnanazwajednostki}}, oznaczająca: pełna nazwa jednostki uzyskana jest, dzięki podanym zmiennym pudełkowym {{m|Pudełko}}, czyli według: {{Code|nazwa przestrzeni nazw}} i {{Code|nazwa jednostki}}, a jeżeli jakaś z tych zmiennych nie została podana, to traktowana jest, jakby była podana, w takim razie te niepodane są liczona na podstawie parametrów aktualnej strony, a jeśli są niepodane, wtedy jest sprawdzane jedynie ich nieistnienie, na podstawie tego wszystkiego jest liczona pełna nazwa jednostki, przy pomocy funkcji: {{sr|#p["Pełna nazwa jednostki"](frame,...)|p=Pudełko/Tom II}}, z tej zmiennej jest liczona pełna nazwa książki, używając funkcji: {{sr|#m["PEŁNANAZWAKSIĄŻKI"]()|p=Nazwy/Tom IV}} w funkcjach: {{Code|{{sr|#p.Strona_zbiorcza()|p=Sekcja referencyjna}}}} i {{Code|{{sr|#p.Wolumin()|p=Sekcja referencyjna}}}}, parametry pudełek mogą wskazywać na inny artykuł niż aktualny, ale tak nie musi być, byle tylko adres książki się zgadzał z tą aktualną, przy nie podaniu parametrów przestrzennych i jednostki, a z nimi adres woluminy może być inny. ---- Te parametry powyżej są jednocześnie parametrami szablonu {{s|Sekcja referencyjna}} (lub jego wersji skrótowej {{s|sr}}). Te parametry możemy podać też w formie funkcyjnej: <syntaxhighlight lang="lua"> local sekcja_referencyjna_modul=require("Module:Sekcja referencyjna"); local link=sekcja_referencyjna_modul["Sekcja referencyjna"]{args={strona=..., nazwa=.., podstrona=..., ...}}; </syntaxhighlight> W ramce funkcyjnej parametry ze znakami nienależącymi do alfabetu łacińskiego piszmy w cudzysłowach w nawiasach kwadratowych, czyli w formie: {{Code|["pod-ustęp"]{{=}}...}}, czy parametry numerowe w nawiasach bez cudzysłowu: {{Code|[1]{{=}}...}}, a parametry normalne piszemy: {{Code|strona{{=}}...}}. Funkcja w uruchamianiu ma dwa warianty, na normalnej stronie niezbiorczej uruchamiana jest funkcja {{Code|{{sr|#p.Wolumin()|p=Sekcja referencyjna}}}}, a na jakikolwiek stronie zbiorczej według Stronicowego Parsera na podstawie modułu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli strony zefiniowanej w: {{Code|{{m|StronicowyParser/StronaSubst}}}}, jest uruchamiana funkcja: {{Code|{{sr|#p.Strona_zbiorcza()|p=Sekcja referencyjna}}}} (a ta przedostatnia jest uruchamiana przez funkcję: {{Code|{{m|StronicowyParser|CzyStronaSubst}}}}, która zwraca wynik {{Code|tak}}, gdy strona dana jest bieżąca lub podana na podstawie parametrów pudełkowych: {{Code|{{m|Pudełko}}}}, która jest stroną zbiorczą, w przeciwnym wypadku mamy wynik: {{Code|nil}}, gdy nie). {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> lawktq9f6ups3z3k7vviyxl4a0y9d7h 541373 541370 2026-04-30T11:44:17Z Persino 2851 /* {{Code|p["Sekcja referencyjna"](frame)}} */ 541373 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Sekcja referencyjna}}|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 sekcja_referencyjna_modul=require("Module:Sekcja referencyjna"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Ta funkcja o nazwie: {{Code|{{sr|#p["Sekcja referencyjna"]()|p=Sekcja referencyjna}}}}, jak i szablon: {{Code|{{s|Sekcja referencyjna}}}} (lub jego wersja skrótowa: {{Code|{{s|sr}}}} - w postaci przekierowania do jego dłuższej wersji), służy do wyświetlania na normalnej lub stronie zbiorczej linków inteligentnych danego podręcznika, jeżeli podamy jego artykuł wraz z, lub bez, nagłówka, lub nagłówek z hashem, z artykułem w zmiennej w: {{Code|podstrona}} (lub ten parametr podany w wersji skrótowej {{Code|p}}), też można linkować do strony głównej podręcznika, nie podając żadnego artykułu w funkcji w: {{sr|#p["Sekcja referencyjna"]()|p=Sekcja referencyjna}}, w zmiennej: {{Code|strona}} (lub w wersji jego skrótowej {{Code|s}}), i w zmiennej w jego pierwszym parametrze numerowanym, lub w jego wersji szablonowej. Ta funkcja lub jego odpowiednik szablonowy wyświetla na stronie normalnej artykułu link do artykułu, a na stronie zbiorczej link do identyfikatora jakiegoś obiektu na stronie. Inne funkcje użyte w module: {{Code|{{ld2|Sekcja referencyjna}}}}, są funkcjami pomocniczymi do głównej jego funkcji, która służy do wywołania w ramce w jego odpowiedniku szablonowym, podany tutaj na samym początku tej strony, te funkcje służą też do użycia w innych modułach, np.: {{ld2|StronicowyParser/Potrzebne}}. Funkcje tutaj opisują obsługę linków inteligentnych (tzw. linki inteligentne), który koloruje linki w zależności do jakiej kategorii szablon zaliczy stronę wskazaną w nim. Zestaw możliwych kodów linkowych, znajduje się na stronie {{s|Link wewnętrzny}}, w miejscu pod tabelą nawigacyjną {{s|Tabela nawigacyjna}}, według jego wikikodu opisu. === Dlaczego te funkcje w opisywanym module, jak i szablon, o który jest zdefiniowany === Moduł {{ld2|Sekcja referencyjna}}, i też szablon {{s|Sekcja referencyjna}} (używany w postaci przekierowania do niego {{s|sr}}), który wykorzystuje ten moduł do swojej definicji, zostały stworzone do używania w spisach treści, oraz wewnątrz zwyczajnych stron książki jako odnośnik do sekcji (rozdziału/podrozdziału/itp.). Ideą tego modułu (szablonu) było rozwiązanie pewnego problemu pojawiającego się, gdy strona zostanie wydrukowana w formie PDF-a, ale nie na papier. Normalnie, gdy spis treści zawiera linki do rozdziałów tworzonych normalnym sposobem (przez wikilinki), to w wydrukowanej formie te linki zostają odnośnikami bezwzględnymi do strony Wikibooks. Gdy użytkownik kliknie w taki link w PDF-ie, to zostanie przekierowany do przeglądarki WWW z otwartą stroną Wikibooks. Psuje to użytkowanie takiej strony, gdyż użytkownik zazwyczaj zakłada, że gdy kliknie na odnośnik w spisie treści, to ten przeniesie go na odpowiednią stronę ''wewnątrz'' PDF-a. Ten moduł (szablon) rozwiązuje ten problem, przez warunkową zamianę linków do stron sekcji w linki lokalne do sekcji wewnątrz strony do druku. W niektórych generatorach PDF-a taka zamiana skutkuje tym, że takie linki umieszczone w spisach treści, powodują przeniesienie do odpowiedniej strony, a nie przeskok do strony WWW (pozostałe generatory po prostu nie generują linków w ogóle). == {{Code|p.Indentyfikator_lub_podstrona_wikiadresu_strony()}} == Funkcja zwraca nagłówek strony, jeżeli istnieje, lub jego podstronę, a jeżeli ona nie ma żadnej podstrony według tego adresu, to cały ten adres, który nie jest adresem {{Strong|HTML}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Indentyfikator_lub_podstrona_wikiadresu_strony(ustep,czy_ustep)...end; </syntaxhighlight> Parametry funkcji: * {{Code|ustep}} - nazwa strony ustępu strony, co z niego robimy nazwę linku, * {{Code|czy_ustep}} - jeżeli {{Code|true}} liczy wtedy nagłówek, a jeżeli tego nie ma to podstronę. Jeżeli {{Code|ustep{{=}}nil}}, w takim razie jest zwracana wartość parametru tego, czyli {{Code|nil}}. Aby nie uzyskać identyfikatora strony, to drugi parametr, czyli {{Code|czy_ustep}}, nie może przyjmować wartości logicznej {{Code|true}}, tylko jako {{Code|false}} lub {{Code|nil}} - wtedy zwracana jest wartość argumentu {{Code|ustęp}}. A jeżeli podamy wartość {{Code|true}}, gdy zmienna {{Code|ustep}} zawiera nagłówek, to zwracany jest właśnie on bez znaku {{Code|#}}, a jeżeli nie zawiera on tego, tylko podstronę, wtedy zwracana jest jego podstrona. W przeciwny wypadku zwracana jest sama wartość argumentu {{Code|ustep}}. == {{Code|p.Nazwa_od_niewielkiej_lub_wielkiej_litery()}} == Funkcja zamienia w nazwie linku pierwszy znak, który jest od litery, aby był od dużej lub małej litery, w zależności od parametrów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwa_od_niewielkiej_lub_wielkiej_litery(nazwa,od_malej,od_duzej)...end; </syntaxhighlight> Parametry funkcji: * {{Code|nazwa}} - nazwa linku strony, * {{Code|od malej}} - zamienia pierwszą literę, pierwszy znak, nazwy linku na małą literę, * {{Code|od dużej}} - zamienia pierwszą literę, pierwszy znak, nazwy linku na dużą literę. Te parametry nie mogą się zaprzeczać między sobą, tzn. oba ostatnie parametry nie mogą być nie {{Code|true}}. W przeciwny wypadku funkcja zwraca samą nieprzekształconą nazwę strony. == {{Code|p.Strona_zbiorcza()}} == Funkcja tworzy link na stronie zbiorczej sama do siebie do elementu wskazywanego przez stworzony nagłówek z parametrów tej funkcji. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Strona_zbiorcza(strona,podstrona,nazwa,czy_ustep,czy_pod_ustep,od_malej,od_duzej,pelnanazwajednostki)...end; </syntaxhighlight> Wartości opcjonalne powyżej przyjmują wartość {{Code|nil}}, wtedy możemy je uznać tak, jak by je, nie podaliśmy. Funkcja przyjmuje parametry podane w tym rozdziale w parametrach tej funkcji, w jego definicji skrótowej, według zmiennych podanych w parametrach zdefiniowanych jako w punkcie dla funkcji {{Code|{{sr|#p["Sekcja referencyjna"](frame)|p=Sekcja referencyjna}}}}, przy których znajduje się ich opis, podanych przy jego parametrach. Nagłówek strony jest tworzony z: {{Code|strona}} i {{Code|podstrona}}, także na podstawie parametru {{Code|czy_pod_ustep}}, gdy magłówek jest pusty, on jesty wyznaczany z: {{Code|pelnanazwajednostki}}, a później jest do tego wykorzystywana zmienna: {{Code|czy_pod_ustep}}, do liczenia właściwego nagłówka. Parametr nazwy linku jest w zmiennej {{Code|nazwa}}, a jezeli ona nie istnieje, wtedy wykorzystujemy do tego element {{Code|strona}}, do którego wykorzystywana jest w: {{Code|{{sr|#p.Indentyfikator_lub_podstrona_wikiadresu_strony()|p=Sekcja referencyjna}}}}, która nie zawsze musi modyfikować tą zmiennej. Funkcja {{Code|{{sr|#p.Nazwa_od_niewielkiej_lub_wielkiej_litery()|p=Sekcja referencyjna}}}} ustala odpowiednio zmodyfikowaną nazwę, według zmiennych, które powinny być niesprzeczne, chodzi tu o: {{Code|od_malej}} i {{Code|od_duzej}}, w przeciwnym wypadku lub jeżeli one nie są ustawione, wtedy nazwa linku pozostaje niezmieniona. Funkcja zwraca trzy parametry jednocześnie, czyli nazwę strony, jego nagłówek i nazwę linku. == {{Code|p.Wolumin()}} == Funkcja tworzy link do podnego artykułu podręcznika, ewentualnie z nazwą nagłówka. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Wolumin(strona,podstrona,nazwa,czy_ustep,od_malej,od_duzej,pelnanazwajednostki)...end; </syntaxhighlight> Wartości opcjonalne powyżej przyjmują wartość {{Code|nil}}, wtedy możemy je uznać tak, jak by je, nie podaliśmy. Funkcja przyjmuje parametry podane w tym rozdziale w parametrach tej funkcji, w jego definicji skrótowej, według zmiennych podanych w parametrach zdefiniowanych jako w punkcie dla funkcji {{Code|{{sr|#p["Sekcja referencyjna"](frame)|p=Sekcja referencyjna}}}}, przy których znajduje się ich opis, podanych przy jego parametrach. Jeżeli parametr {{Code|strona}} nie istnieje, to ona jest tworzona na podstawie {{Code|pelnanazwajednostki}}, nie używajac parametru {{Code|podstrona}}. A jeżeli on istnieje, to nowa wartość {{Code|strona}} jest tworzona ze starego {{Code|strona}} i {{Code|podstrona}}. Funkcja zwraca dwa parametry jednocześnie, czyli policzoną nazwę strony, policzonej z parametru {{Code|strona}},ewentualnie {{Code|podstrona}} i nazwę linku z {{Code|nazwa}}, a jeżeli ona nie istnieje to ona jest tworzona z: {{Code|strona}}, wykorzystując funkcję {{Code|{{sr|#p.Indentyfikator_lub_podstrona_wikiadresu_strony()|p=Sekcja referencyjna}}}}. == {{Code|p["Sekcja referencyjna"](frame)}} == Szablon linków inteligentnych z kodami na stronie {{s|Link wewnętrzny}}, który się mieści w tabeli wywołania szablonowego {{s|Tabela nawigacyjna}} w jego parametrze, tam są też linkujące do tej samej strony, czyli do szablonu arkusza stylów, w której został wywołany, ewentualnie do jego identyfikatora danego elementu, mające kolory odpowiednie dla nich, a właściwe wartości kodów znajdują się w znaczniku szablonowym {{s|span}} obok tych odpowiednich elementów. Funkcja koloruje linki w zależności do jakiej kategorii on należy, wskazanych przez kody, a do tego celu używa {{NAZWASERWISU|klucz projektu=d|link=tak}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Sekcja referencyjna"]=function(frame)...end; </syntaxhighlight> Parametrami tablicy ramki modułu, które są podane w rodzicu w szablonie lub w samej ramce, jeżeli jest podany parametr {{Parametr|wyspecjalizowana|tak}} w samej ramce, a one są: * {{Code|1}}, {{Code|s}} lub {{Code|strona}} - jest to artykuł w podręczniku, ewentualnie z nagłówkiem, zdefiniujmy go jako: {{Code|strona}}, * {{Code|2}}, {{Code|n}} lub {{Code|nazwa}} - nazwa linku wyświetlana w artykule, zdefiniujmy go jako: {{Code|nazwa}}, * {{Code|3}}, {{Code|p}} lub {{Code|podstrona}} - podstrona dodawana do linku podczas rozważać, wtedy artykuł, będzie o jeden lub wyżej, głębiej w drzewie danej przestrzeni nazw, zdefiniujmy go jako: {{Code|podstrona}}, * {{Code|4}}. {{Code|u}} lub {{Code|ustęp}} - jeśli przyjmuje wartość niepustą, to nazwa wyświetlana linku jest jego nagłówek, jeżeli istnieje, lub jego podstrona albo sama strona, w przypadku przestrzeni nazw {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}} oraz nibyprzestrzeni nazw {{lr2|Brudnopis}}, w przestrzeni nazw {{Np|Project|link=tak}}, a także przestrzeni użytkownika {{Np|User|link=tak}}, a w przypadku nie podania nazwy strony {{Code|strona}} (lub jego skrót: {{Code|s}}) lub {{Code|1}}, to parametr {{Code|ustęp}} zachowuje się odwrotnie, wtedy nazwę strony, do której linkuje szablon, przyjmujemy domyślnie, że jest to nazwa książki, w przestrzeniach nazw w dwóch pierwszych nie widać różnicy działania tego parametru, już jest różnica w nibyprzestrzeniach nazw dwóch ostatnich, tutaj ten szablon podaje subnazwę książki, a nie jego adres, gdzie przy {{Parametr|ustęp|tak}} (lub jego synonim numerowany: {{Parametr|4|tak}}) (lub jego skrót: {{Parametr|u|tak}}) podaje cały adres, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|czy_ustęp}}, * {{Code|m}}, {{Code|od małej}} - jeśli niepuste, wyświetlany jest link od małej litery, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|od malej}}, * {{Code|d}}, {{Code|od dużej}} - jeśli niepuste, wyświetlany jest link od dużej litery, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|od dużej}}, * {{Code|t}}, {{Code|pod-ustęp}} - na stronach zbiorczych skraca nazwę nagłówka, która na stronie artykułów podręcznika byłaby nazwą strony, do substrony, zdefiujmy go jako: {{Code|czy_pod_ustep}}. ---- W tej funkcji jeszcze jest liczona zmienna: {{Code|pelnanazwajednostki}}, oznaczająca: pełna nazwa jednostki uzyskana jest, dzięki podanym zmiennym pudełkowym {{m|Pudełko}}, czyli według: {{Code|nazwa przestrzeni nazw}} i {{Code|nazwa jednostki}}, a jeżeli jakaś z tych zmiennych nie została podana, to traktowana jest, jakby była podana, w takim razie te niepodane są liczona na podstawie parametrów aktualnej strony, a jeśli są niepodane, wtedy jest sprawdzane jedynie ich nieistnienie, na podstawie tego wszystkiego jest liczona pełna nazwa jednostki, przy pomocy funkcji: {{sr|#p["Pełna nazwa jednostki"](frame,...)|p=Pudełko/Tom II}}, z tej zmiennej jest liczona pełna nazwa książki, używając funkcji: {{sr|#m["PEŁNANAZWAKSIĄŻKI"]()|p=Nazwy/Tom IV}} w funkcjach: {{Code|{{sr|#p.Strona_zbiorcza()|p=Sekcja referencyjna}}}} i {{Code|{{sr|#p.Wolumin()|p=Sekcja referencyjna}}}}, parametry pudełek mogą wskazywać na inny artykuł niż aktualny, ale tak nie musi być, byle tylko adres książki się zgadzał z tą aktualną, przy nie podaniu parametrów przestrzennych i jednostki, a z nimi adres woluminy może być inny. ---- Te parametry powyżej są jednocześnie parametrami szablonu {{s|Sekcja referencyjna}} (lub jego wersji skrótowej {{s|sr}}). Te parametry możemy podać też w formie funkcyjnej: <syntaxhighlight lang="lua"> local sekcja_referencyjna_modul=require("Module:Sekcja referencyjna"); local link=sekcja_referencyjna_modul["Sekcja referencyjna"]{args={strona=..., nazwa=.., podstrona=..., ...}}; </syntaxhighlight> W ramce funkcyjnej parametry ze znakami nienależącymi do alfabetu łacińskiego piszmy w cudzysłowach w nawiasach kwadratowych, czyli w formie: {{Code|["pod-ustęp"]{{=}}...}}, czy parametry numerowe w nawiasach bez cudzysłowu: {{Code|[1]{{=}}...}}, a parametry normalne piszemy: {{Code|strona{{=}}...}}. Funkcja w uruchamianiu ma dwa warianty, na normalnej stronie niezbiorczej uruchamiana jest funkcja {{Code|{{sr|#p.Wolumin()|p=Sekcja referencyjna}}}}, a na jakikolwiek stronie zbiorczej według Stronicowego Parsera na podstawie modułu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli strony zefiniowanej w: {{Code|{{m|StronicowyParser/StronaSubst}}}}, jest uruchamiana funkcja: {{Code|{{sr|#p.Strona_zbiorcza()|p=Sekcja referencyjna}}}} (a ta przedostatnia jest uruchamiana przez funkcję: {{Code|{{m|StronicowyParser|CzyStronaSubst}}}}, która zwraca wynik {{Code|tak}}, gdy strona dana jest bieżąca lub podana na podstawie parametrów pudełkowych: {{Code|{{m|Pudełko}}}}, która jest stroną zbiorczą, w przeciwnym wypadku mamy wynik: {{Code|nil}}, gdy nie). {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> b6cja9hch8sg2n3pg9ay60fmryripq1 541374 541373 2026-04-30T11:58:25Z Persino 2851 /* {{Code|p["Sekcja referencyjna"](frame)}} */ 541374 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Sekcja referencyjna}}|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 sekcja_referencyjna_modul=require("Module:Sekcja referencyjna"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Ta funkcja o nazwie: {{Code|{{sr|#p["Sekcja referencyjna"]()|p=Sekcja referencyjna}}}}, jak i szablon: {{Code|{{s|Sekcja referencyjna}}}} (lub jego wersja skrótowa: {{Code|{{s|sr}}}} - w postaci przekierowania do jego dłuższej wersji), służy do wyświetlania na normalnej lub stronie zbiorczej linków inteligentnych danego podręcznika, jeżeli podamy jego artykuł wraz z, lub bez, nagłówka, lub nagłówek z hashem, z artykułem w zmiennej w: {{Code|podstrona}} (lub ten parametr podany w wersji skrótowej {{Code|p}}), też można linkować do strony głównej podręcznika, nie podając żadnego artykułu w funkcji w: {{sr|#p["Sekcja referencyjna"]()|p=Sekcja referencyjna}}, w zmiennej: {{Code|strona}} (lub w wersji jego skrótowej {{Code|s}}), i w zmiennej w jego pierwszym parametrze numerowanym, lub w jego wersji szablonowej. Ta funkcja lub jego odpowiednik szablonowy wyświetla na stronie normalnej artykułu link do artykułu, a na stronie zbiorczej link do identyfikatora jakiegoś obiektu na stronie. Inne funkcje użyte w module: {{Code|{{ld2|Sekcja referencyjna}}}}, są funkcjami pomocniczymi do głównej jego funkcji, która służy do wywołania w ramce w jego odpowiedniku szablonowym, podany tutaj na samym początku tej strony, te funkcje służą też do użycia w innych modułach, np.: {{ld2|StronicowyParser/Potrzebne}}. Funkcje tutaj opisują obsługę linków inteligentnych (tzw. linki inteligentne), który koloruje linki w zależności do jakiej kategorii szablon zaliczy stronę wskazaną w nim. Zestaw możliwych kodów linkowych, znajduje się na stronie {{s|Link wewnętrzny}}, w miejscu pod tabelą nawigacyjną {{s|Tabela nawigacyjna}}, według jego wikikodu opisu. === Dlaczego te funkcje w opisywanym module, jak i szablon, o który jest zdefiniowany === Moduł {{ld2|Sekcja referencyjna}}, i też szablon {{s|Sekcja referencyjna}} (używany w postaci przekierowania do niego {{s|sr}}), który wykorzystuje ten moduł do swojej definicji, zostały stworzone do używania w spisach treści, oraz wewnątrz zwyczajnych stron książki jako odnośnik do sekcji (rozdziału/podrozdziału/itp.). Ideą tego modułu (szablonu) było rozwiązanie pewnego problemu pojawiającego się, gdy strona zostanie wydrukowana w formie PDF-a, ale nie na papier. Normalnie, gdy spis treści zawiera linki do rozdziałów tworzonych normalnym sposobem (przez wikilinki), to w wydrukowanej formie te linki zostają odnośnikami bezwzględnymi do strony Wikibooks. Gdy użytkownik kliknie w taki link w PDF-ie, to zostanie przekierowany do przeglądarki WWW z otwartą stroną Wikibooks. Psuje to użytkowanie takiej strony, gdyż użytkownik zazwyczaj zakłada, że gdy kliknie na odnośnik w spisie treści, to ten przeniesie go na odpowiednią stronę ''wewnątrz'' PDF-a. Ten moduł (szablon) rozwiązuje ten problem, przez warunkową zamianę linków do stron sekcji w linki lokalne do sekcji wewnątrz strony do druku. W niektórych generatorach PDF-a taka zamiana skutkuje tym, że takie linki umieszczone w spisach treści, powodują przeniesienie do odpowiedniej strony, a nie przeskok do strony WWW (pozostałe generatory po prostu nie generują linków w ogóle). == {{Code|p.Indentyfikator_lub_podstrona_wikiadresu_strony()}} == Funkcja zwraca nagłówek strony, jeżeli istnieje, lub jego podstronę, a jeżeli ona nie ma żadnej podstrony według tego adresu, to cały ten adres, który nie jest adresem {{Strong|HTML}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Indentyfikator_lub_podstrona_wikiadresu_strony(ustep,czy_ustep)...end; </syntaxhighlight> Parametry funkcji: * {{Code|ustep}} - nazwa strony ustępu strony, co z niego robimy nazwę linku, * {{Code|czy_ustep}} - jeżeli {{Code|true}} liczy wtedy nagłówek, a jeżeli tego nie ma to podstronę. Jeżeli {{Code|ustep{{=}}nil}}, w takim razie jest zwracana wartość parametru tego, czyli {{Code|nil}}. Aby nie uzyskać identyfikatora strony, to drugi parametr, czyli {{Code|czy_ustep}}, nie może przyjmować wartości logicznej {{Code|true}}, tylko jako {{Code|false}} lub {{Code|nil}} - wtedy zwracana jest wartość argumentu {{Code|ustęp}}. A jeżeli podamy wartość {{Code|true}}, gdy zmienna {{Code|ustep}} zawiera nagłówek, to zwracany jest właśnie on bez znaku {{Code|#}}, a jeżeli nie zawiera on tego, tylko podstronę, wtedy zwracana jest jego podstrona. W przeciwny wypadku zwracana jest sama wartość argumentu {{Code|ustep}}. == {{Code|p.Nazwa_od_niewielkiej_lub_wielkiej_litery()}} == Funkcja zamienia w nazwie linku pierwszy znak, który jest od litery, aby był od dużej lub małej litery, w zależności od parametrów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwa_od_niewielkiej_lub_wielkiej_litery(nazwa,od_malej,od_duzej)...end; </syntaxhighlight> Parametry funkcji: * {{Code|nazwa}} - nazwa linku strony, * {{Code|od malej}} - zamienia pierwszą literę, pierwszy znak, nazwy linku na małą literę, * {{Code|od dużej}} - zamienia pierwszą literę, pierwszy znak, nazwy linku na dużą literę. Te parametry nie mogą się zaprzeczać między sobą, tzn. oba ostatnie parametry nie mogą być nie {{Code|true}}. W przeciwny wypadku funkcja zwraca samą nieprzekształconą nazwę strony. == {{Code|p.Strona_zbiorcza()}} == Funkcja tworzy link na stronie zbiorczej sama do siebie do elementu wskazywanego przez stworzony nagłówek z parametrów tej funkcji. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Strona_zbiorcza(strona,podstrona,nazwa,czy_ustep,czy_pod_ustep,od_malej,od_duzej,pelnanazwajednostki)...end; </syntaxhighlight> Wartości opcjonalne powyżej przyjmują wartość {{Code|nil}}, wtedy możemy je uznać tak, jak by je, nie podaliśmy. Funkcja przyjmuje parametry podane w tym rozdziale w parametrach tej funkcji, w jego definicji skrótowej, według zmiennych podanych w parametrach zdefiniowanych jako w punkcie dla funkcji {{Code|{{sr|#p["Sekcja referencyjna"](frame)|p=Sekcja referencyjna}}}}, przy których znajduje się ich opis, podanych przy jego parametrach. Nagłówek strony jest tworzony z: {{Code|strona}} i {{Code|podstrona}}, także na podstawie parametru {{Code|czy_pod_ustep}}, gdy magłówek jest pusty, on jesty wyznaczany z: {{Code|pelnanazwajednostki}}, a później jest do tego wykorzystywana zmienna: {{Code|czy_pod_ustep}}, do liczenia właściwego nagłówka. Parametr nazwy linku jest w zmiennej {{Code|nazwa}}, a jezeli ona nie istnieje, wtedy wykorzystujemy do tego element {{Code|strona}}, do którego wykorzystywana jest w: {{Code|{{sr|#p.Indentyfikator_lub_podstrona_wikiadresu_strony()|p=Sekcja referencyjna}}}}, która nie zawsze musi modyfikować tą zmiennej. Funkcja {{Code|{{sr|#p.Nazwa_od_niewielkiej_lub_wielkiej_litery()|p=Sekcja referencyjna}}}} ustala odpowiednio zmodyfikowaną nazwę, według zmiennych, które powinny być niesprzeczne, chodzi tu o: {{Code|od_malej}} i {{Code|od_duzej}}, w przeciwnym wypadku lub jeżeli one nie są ustawione, wtedy nazwa linku pozostaje niezmieniona. Funkcja zwraca trzy parametry jednocześnie, czyli nazwę strony, jego nagłówek i nazwę linku. == {{Code|p.Wolumin()}} == Funkcja tworzy link do podnego artykułu podręcznika, ewentualnie z nazwą nagłówka. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Wolumin(strona,podstrona,nazwa,czy_ustep,od_malej,od_duzej,pelnanazwajednostki)...end; </syntaxhighlight> Wartości opcjonalne powyżej przyjmują wartość {{Code|nil}}, wtedy możemy je uznać tak, jak by je, nie podaliśmy. Funkcja przyjmuje parametry podane w tym rozdziale w parametrach tej funkcji, w jego definicji skrótowej, według zmiennych podanych w parametrach zdefiniowanych jako w punkcie dla funkcji {{Code|{{sr|#p["Sekcja referencyjna"](frame)|p=Sekcja referencyjna}}}}, przy których znajduje się ich opis, podanych przy jego parametrach. Jeżeli parametr {{Code|strona}} nie istnieje, to ona jest tworzona na podstawie {{Code|pelnanazwajednostki}}, nie używajac parametru {{Code|podstrona}}. A jeżeli on istnieje, to nowa wartość {{Code|strona}} jest tworzona ze starego {{Code|strona}} i {{Code|podstrona}}. Funkcja zwraca dwa parametry jednocześnie, czyli policzoną nazwę strony, policzonej z parametru {{Code|strona}},ewentualnie {{Code|podstrona}} i nazwę linku z {{Code|nazwa}}, a jeżeli ona nie istnieje to ona jest tworzona z: {{Code|strona}}, wykorzystując funkcję {{Code|{{sr|#p.Indentyfikator_lub_podstrona_wikiadresu_strony()|p=Sekcja referencyjna}}}}. == {{Code|p["Sekcja referencyjna"](frame)}} == Szablon stylowy linków inteligentnych, jest on z kodami na stronie {{s|Link wewnętrzny/opis}}, który się mieści pod tabelą wywołania szablonowego {{s|Tabela nawigacyjna}}, a w jego parametrze, tam są też linkujące do tej samej strony, czyli do szablonu arkusza stylów, do której są one, mające kolory odpowiednie dla nich, a właściwe wartości kodów znajdują się w znaczniku szablonowym {{s|span}} obok tych odpowiednich elementów. Funkcja koloruje linki w zależności do jakiej kategorii on należy, wskazanych przez kody, a do tego celu używa {{NAZWASERWISU|klucz projektu=d|link=tak}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Sekcja referencyjna"]=function(frame)...end; </syntaxhighlight> Parametrami tablicy ramki modułu, które są podane w rodzicu w szablonie lub w samej ramce, jeżeli jest podany parametr {{Parametr|wyspecjalizowana|tak}} w samej ramce, a one są: * {{Code|1}}, {{Code|s}} lub {{Code|strona}} - jest to artykuł w podręczniku, ewentualnie z nagłówkiem, zdefiniujmy go jako: {{Code|strona}}, * {{Code|2}}, {{Code|n}} lub {{Code|nazwa}} - nazwa linku wyświetlana w artykule, zdefiniujmy go jako: {{Code|nazwa}}, * {{Code|3}}, {{Code|p}} lub {{Code|podstrona}} - podstrona dodawana do linku podczas rozważać, wtedy artykuł, będzie o jeden lub wyżej, głębiej w drzewie danej przestrzeni nazw, zdefiniujmy go jako: {{Code|podstrona}}, * {{Code|4}}. {{Code|u}} lub {{Code|ustęp}} - jeśli przyjmuje wartość niepustą, to nazwa wyświetlana linku jest jego nagłówek, jeżeli istnieje, lub jego podstrona albo sama strona, w przypadku przestrzeni nazw {{Np|(main)|link=tak}} i {{Np|Wikijunior|link=tak}} oraz nibyprzestrzeni nazw {{lr2|Brudnopis}}, w przestrzeni nazw {{Np|Project|link=tak}}, a także przestrzeni użytkownika {{Np|User|link=tak}}, a w przypadku nie podania nazwy strony {{Code|strona}} (lub jego skrót: {{Code|s}}) lub {{Code|1}}, to parametr {{Code|ustęp}} zachowuje się odwrotnie, wtedy nazwę strony, do której linkuje szablon, przyjmujemy domyślnie, że jest to nazwa książki, w przestrzeniach nazw w dwóch pierwszych nie widać różnicy działania tego parametru, już jest różnica w nibyprzestrzeniach nazw dwóch ostatnich, tutaj ten szablon podaje subnazwę książki, a nie jego adres, gdzie przy {{Parametr|ustęp|tak}} (lub jego synonim numerowany: {{Parametr|4|tak}}) (lub jego skrót: {{Parametr|u|tak}}) podaje cały adres, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|czy_ustęp}}, * {{Code|m}}, {{Code|od małej}} - jeśli niepuste, wyświetlany jest link od małej litery, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|od malej}}, * {{Code|d}}, {{Code|od dużej}} - jeśli niepuste, wyświetlany jest link od dużej litery, zdefiujmy go jako, czy jest o wartości niepustej: {{Code|od dużej}}, * {{Code|t}}, {{Code|pod-ustęp}} - na stronach zbiorczych skraca nazwę nagłówka, która na stronie artykułów podręcznika byłaby nazwą strony, do substrony, zdefiujmy go jako: {{Code|czy_pod_ustep}}. ---- W tej funkcji jeszcze jest liczona zmienna: {{Code|pelnanazwajednostki}}, oznaczająca: pełna nazwa jednostki uzyskana jest, dzięki podanym zmiennym pudełkowym {{m|Pudełko}}, czyli według: {{Code|nazwa przestrzeni nazw}} i {{Code|nazwa jednostki}}, a jeżeli jakaś z tych zmiennych nie została podana, to traktowana jest, jakby była podana, w takim razie te niepodane są liczona na podstawie parametrów aktualnej strony, a jeśli są niepodane, wtedy jest sprawdzane jedynie ich nieistnienie, na podstawie tego wszystkiego jest liczona pełna nazwa jednostki, przy pomocy funkcji: {{sr|#p["Pełna nazwa jednostki"](frame,...)|p=Pudełko/Tom II}}, z tej zmiennej jest liczona pełna nazwa książki, używając funkcji: {{sr|#m["PEŁNANAZWAKSIĄŻKI"]()|p=Nazwy/Tom IV}} w funkcjach: {{Code|{{sr|#p.Strona_zbiorcza()|p=Sekcja referencyjna}}}} i {{Code|{{sr|#p.Wolumin()|p=Sekcja referencyjna}}}}, parametry pudełek mogą wskazywać na inny artykuł niż aktualny, ale tak nie musi być, byle tylko adres książki się zgadzał z tą aktualną, przy nie podaniu parametrów przestrzennych i jednostki, a z nimi adres woluminy może być inny. ---- Te parametry powyżej są jednocześnie parametrami szablonu {{s|Sekcja referencyjna}} (lub jego wersji skrótowej {{s|sr}}). Te parametry możemy podać też w formie funkcyjnej: <syntaxhighlight lang="lua"> local sekcja_referencyjna_modul=require("Module:Sekcja referencyjna"); local link=sekcja_referencyjna_modul["Sekcja referencyjna"]{args={strona=..., nazwa=.., podstrona=..., ...}}; </syntaxhighlight> W ramce funkcyjnej parametry ze znakami nienależącymi do alfabetu łacińskiego piszmy w cudzysłowach w nawiasach kwadratowych, czyli w formie: {{Code|["pod-ustęp"]{{=}}...}}, czy parametry numerowe w nawiasach bez cudzysłowu: {{Code|[1]{{=}}...}}, a parametry normalne piszemy: {{Code|strona{{=}}...}}. Funkcja w uruchamianiu ma dwa warianty, na normalnej stronie niezbiorczej uruchamiana jest funkcja {{Code|{{sr|#p.Wolumin()|p=Sekcja referencyjna}}}}, a na jakikolwiek stronie zbiorczej według Stronicowego Parsera na podstawie modułu {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli strony zefiniowanej w: {{Code|{{m|StronicowyParser/StronaSubst}}}}, jest uruchamiana funkcja: {{Code|{{sr|#p.Strona_zbiorcza()|p=Sekcja referencyjna}}}} (a ta przedostatnia jest uruchamiana przez funkcję: {{Code|{{m|StronicowyParser|CzyStronaSubst}}}}, która zwraca wynik {{Code|tak}}, gdy strona dana jest bieżąca lub podana na podstawie parametrów pudełkowych: {{Code|{{m|Pudełko}}}}, która jest stroną zbiorczą, w przeciwnym wypadku mamy wynik: {{Code|nil}}, gdy nie). {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ab1asxufaf47zd154zk48bw5dk9lzfb 4 63291 541309 541307 2026-04-29T15:49:40Z Persino 2851 /* {{Code|p["KopiujTabelęŁańcuchów"]()}} */ 541309 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> n0g25f6z5ji0qxlr4f1ciqfjyi1qcwv 541311 541309 2026-04-29T16:32:31Z Persino 2851 /* Funkcje, czy są takie parametry */ 541311 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 9j8sh1zdifmj2solwrz219m06fyhbut 541312 541311 2026-04-29T16:34:00Z Persino 2851 /* {{Code|p["CzySąElementyNumerowaneTablicy"]()}} */ 541312 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ml6dvm54ffce0eomlihjmg6lzf2apb2 541313 541312 2026-04-29T16:35:25Z Persino 2851 /* {{Code|p["CzySąElementyNienazwaneTablicy"]()}} */ 541313 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|false}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 2d3vptzfnzsrz2jzssj09xlhiopaoqn 541314 541313 2026-04-29T16:38:32Z Persino 2851 /* Funkcje, czy są takie parametry */ 541314 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|false}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> gol0umufvuu0wsjq77e197yqwg1muee 541315 541314 2026-04-29T16:40:18Z Persino 2851 541315 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|nil}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ttp3y1onzo0dtmf7lnf1ryoezo9h6oe 541316 541315 2026-04-29T16:44:26Z Persino 2851 /* {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} */ 541316 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ah9rugoqdj3xlu8vu6xqjgis8zz17o7 541318 541316 2026-04-29T16:56:04Z Persino 2851 /* {{Code|p["CzySąElementyNazwaneTablicy"]()}} */ 541318 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od tej liczby, czyli: {{Code|1,2,3,4,...}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nnumerowwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany od {{Code|1}} bez przerw. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. Jak można zauważyć, że ma on parametry numerowanych (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, niekoniecznie, mieć przerwy, np.:{{Code|3,10,15,..}}, liczbę elementów tablicy. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie. <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji na poziomie ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}}, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, i czy one występuje w postaci mnogiej: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogiej, tzn. gdy ten parametr jest podany, czy jest w liczbie większej niż {{Code|1}}. Powyższa funkcja zrzuca wynik wyliczony, ze względu na mnogość podaną w dziecku tego szablonu, liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy nie o zawartości niepustej. <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe w postaci czystych liczb, czy też również w postaci łańcuchów, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}} są czystymi liczbami {{lpg|Lua}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}}: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w parametrze dziecka ramki. <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}}: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie, przerwy, niekoniecznie zaczynający się jedynki, o pewnej podstawie. <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np.: dla parametrów: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, są kolejno: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 0kzq72zgq1tbskij0uqcns98sqiiyl0 541321 541318 2026-04-30T00:33:56Z Persino 2851 541321 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Szablon zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli, w której jest wywołana ta funkcja ramki. <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> scdyxihji6mmfzomieumoss81nly1lp 541322 541321 2026-04-30T00:50:01Z Persino 2851 /* Funkcje, czy są takie parametry */ 541322 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowaniem poszczególnych elementów ściśle dla niego, a jeżeli nie ma dla niego składowych szczególnych, to ogólnie. Z tak uzyskanej tabeli wyodrębniamy pewne elementy szczególnie lub ogólnie, jak z zastępowaniem. A jeśli coś uzyskamy coś, to do niego dodawany jest przedrostek i przyrostek, a podstawie tego tworzymy nową tabelę {{Code|args2}}, którą zwracamy przez tę funkcję. <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, są składowe, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, o wartościach pustych lub fałszywych przy pomocy funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A więc: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Więc: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji są: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}} wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 67skhza5kmw72c5k0i4t5jlh479l4im 541323 541322 2026-04-30T01:06:23Z Persino 2851 /* Funkcje kopiowania tabel */ 541323 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie np. wygląda: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> A wywołanie szablonowe wygląda: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> rijlt9ikgf4li91m6savjhomiytx9at 541324 541323 2026-04-30T01:13:59Z Persino 2851 /* Funkcje istnienia parametrów */ 541324 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji są: Poniższe przykłady są pokazane za pomocą szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> W pierwszym i drugiej wartości w naszym wypadku funkcja zwróci wartość: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 8utpdkkyynj27wdl6n81zx9xzs1zcdn 541325 541324 2026-04-30T01:18:02Z Persino 2851 /* Funkcje manipulowania formatów łańcuchów znakowych */ 541325 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Jej definicji jest: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykładem użycia funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w takim wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 9e651gb3y62s6gpeuus56q2mxzdgjt4 541326 541325 2026-04-30T01:19:24Z Persino 2851 /* Funkcje dodawania lub usuwania elementu do tabeli zbioru */ 541326 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, numerowanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych, jak i numerowanych. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> sliy83eflkzv0ulmah5qt24cndfcyik 541327 541326 2026-04-30T01:25:28Z Persino 2851 /* Funkcje istnienia elementów tabeli */ 541327 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób numerowany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Tabele są podane w pierwszej tabeli {{Code|args}}, w której tabele są podane w sposób nienazwany, tzn. określone liczbami naturalnymi, w drugiej tabeli {{Code|args2}} są podane ustawienia tej podanej funkcji bibliotecznej. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja jej jest: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> i5tywjs20lyswa3aqyoj4s9q55tob6i 541328 541327 2026-04-30T01:50:52Z Persino 2851 /* Łączenie wielu tabel */ 541328 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ie0cpcix99j6zp23rg6sbnii81tup8i 541329 541328 2026-04-30T01:54:03Z Persino 2851 /* Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach */ 541329 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}. Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykład działania: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to nie ma takiej samej referencji, co {{Code|tabelka_1}}, tylko inną, ma za to elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> sp1d7vlfme67q8cmi5ag9bbrf4oeofc 541330 541329 2026-04-30T02:04:01Z Persino 2851 /* Tworzenie tabeli */ 541330 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 2ut01h344ic1h0fmtr0d1ihab5lwd2p 541331 541330 2026-04-30T02:04:42Z Persino 2851 /* {{Code|p["UsuńElementyTabeli"]()}} */ 541331 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> cjbl1e44o286n2xw65s6p62le8ajtv4 541332 541331 2026-04-30T02:07:54Z Persino 2851 /* Funkcje typu */ 541332 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, to ona zbiera argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), ich klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Dla {{Code|args[2]}} funkcja uruchamia bibliotekę o tej właśnie nazwie, a w niej funkcję określoną argumentem {{Code|args[1]}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} , jeśli ma wtedy o wartość: {{Code|"true"}}, wtedy ta zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniowć atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość podana zawiera znaki nierówne odstępowi, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. Ta funkcja w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służy do sprawdzenia, czy wartość, czy jest nierówna ciągowi pustemu, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> m3kg3i1y18pcnj8vyhap5nx2cghhmhh 541333 541332 2026-04-30T02:47:30Z Persino 2851 /* Funkcje prawdy i fałszu */ 541333 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja, taka że w obu przypadkach działa, jest funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcja, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}} jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałśzywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli zmienna: wartosc, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna nie jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i tak uzyskanej tablicy {{Code|args}}, także za pomocą spójnika {{Code|or}}, pisząc np. {{Code|nazwa1{{=}}args["nazwa1"] or args[1]}}, gdzie np. w tym przykładzie wartość klucza {{Code|nazwa1}} o pewnej wartości, która jest wartością z tablicy podaną jako tylko jeden parametr do funkcji w jakimś sposobie podawania argumentów, a {{Code|args[1]}}, jest to pierwszy parametr funkcji, jeżeli w funkcji zmienne podajemy w postaci wielu parametrów, znów jeszcze w innym sposobie realizacji argumentów w argumencie w tej samej funkcji. A ten wspomniany skrót wygląda: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennych {{Code|args}} dostaliśmy się do parametrów, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy tablicę {{Code|args}}, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, któremu wartością odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=args["nazwa1"] or args[1]; local wartosc2=args["nazwa2"] or args[2]; local wartosc3=args["nazwa3"] or args[3]; end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|args}}, podane też jako zmienna, pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie, ta zwrócona z funkcji z nagłówka, dwa parametry, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer _metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten krok pętli, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musibyć tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 14twf57nl2jp292e9ead18vnmgstyg2 541334 541333 2026-04-30T03:58:44Z Persino 2851 /* Funkcje parametrów */ 541334 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica transportu ramki. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica transportu ramki, * {{Code|czy_nie_tablica_jako_tablica}} - czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcji w nagłówku, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> g19qjhsz1o687g2g1fk8rx6bi8uc81i 541335 541334 2026-04-30T04:07:51Z Persino 2851 /* Funkcje wartości logicznej */ 541335 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, poieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica transportu ramki. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica transportu ramki, * {{Code|czy_nie_tablica_jako_tablica}} - czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcji w nagłówku, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> bc2j8mc75w2wzzammk5dhp9axyu8hxm 541336 541335 2026-04-30T04:28:05Z Persino 2851 /* {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} */ 541336 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica transportu ramki. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica transportu ramki, * {{Code|czy_nie_tablica_jako_tablica}} - czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcji w nagłówku, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje, czyli: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji jest: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum, definicja skrótowa, jest: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> dvecakyhtlwlc24l5zx9ai86kio5c39 541337 541336 2026-04-30T05:29:14Z Persino 2851 541337 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica, z główną tablicą, z elementami modyfikującymi elemenenty i je zmienione sprawdzające, a następnie dodające do nich przedrostki i przyrostki. Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów numerowanych, * {{Code|wartosc}} - wartość, którą wsadzamy jako ostatni element do tej tablicy. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko numerowanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu numerowanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko nienazwwanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu nienazwanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać, * {{Code|wartość}} - wartość tego klucza, jaką ta tabela powinna posiadać. Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}} i {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tabela elementów będących tabelami, * {{Code|args2}} - tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Parametry: * {{Code|tabela_1}} - tabela elementów, * {{Code|tabela_2}} - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args[1]}} - tabela elementów, * {{Code|args[2]}}, {{Code|args[3]}},... - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. * {{Code|funkcja}} - funkcja za pomocą której sprawdzamy logiczną tej tablicy Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica transportu ramki, * {{Code|czy_nie_tablica_jako_tablica}} - czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcji w nagłówku, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} - parametry logiczne dodatkowe funkcji. Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry: * {{Code|t}} - tablica, po której iterujemy po elemenetach numerowanych. Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, po której iterujemy, * {{Code|funkcja}} - funkcja sortująca. Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> fdvpg2niucww3hfri6xlhedhpo56r02 541338 541337 2026-04-30T05:33:49Z Persino 2851 /* {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} */ 541338 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica, z główną tablicą, z elementami modyfikującymi elemenenty i je zmienione sprawdzające, a następnie dodające do nich przedrostki i przyrostki. Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów numerowanych, * {{Code|wartosc}} - wartość, którą wsadzamy jako ostatni element do tej tablicy. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko numerowanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu numerowanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko nienazwwanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu nienazwanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać, * {{Code|wartość}} - wartość tego klucza, jaką ta tabela powinna posiadać. Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}} i {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tabela elementów będących tabelami, * {{Code|args2}} - tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Parametry: * {{Code|tabela_1}} - tabela elementów, * {{Code|tabela_2}} - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args[1]}} - tabela elementów, * {{Code|args[2]}}, {{Code|args[3]}},... - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. * {{Code|funkcja}} - funkcja za pomocą której sprawdzamy logiczną tej tablicy Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica transportu ramki, * {{Code|czy_nie_tablica_jako_tablica}} - czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcji w nagłówku, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} - parametry logiczne dodatkowe funkcji. Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry: * {{Code|t}} - tablica, po której iterujemy po elemenetach numerowanych. Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, po której iterujemy, * {{Code|funkcja}} - funkcja sortująca. Parametry funkcji zwracanej: * {{Code|tablica}} - tabela operowana, * {{Code|klucz}} - klucz, dzięki któremu szukamy następny element. Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> t28jvpqxm4n5qxf5h4veicxn5rbt2l9 541339 541338 2026-04-30T05:43:29Z Persino 2851 /* Funkcje prawdy i fałszu */ 541339 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica, z główną tablicą, z elementami modyfikującymi elemenenty i je zmienione sprawdzające, a następnie dodające do nich przedrostki i przyrostki. Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów numerowanych, * {{Code|wartosc}} - wartość, którą wsadzamy jako ostatni element do tej tablicy. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko numerowanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu numerowanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko nienazwwanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu nienazwanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać, * {{Code|wartość}} - wartość tego klucza, jaką ta tabela powinna posiadać. Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}} i {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tabela elementów będących tabelami, * {{Code|args2}} - tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Parametry: * {{Code|tabela_1}} - tabela elementów, * {{Code|tabela_2}} - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args[1]}} - tabela elementów, * {{Code|args[2]}}, {{Code|args[3]}},... - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. * {{Code|funkcja}} - funkcja za pomocą której sprawdzamy logiczną tej tablicy Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, może być to funkcją, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica transportu ramki, * {{Code|czy_nie_tablica_jako_tablica}} - czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcji w nagłówku, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} - parametry logiczne dodatkowe funkcji. Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry: * {{Code|t}} - tablica, po której iterujemy po elemenetach numerowanych. Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, po której iterujemy, * {{Code|funkcja}} - funkcja sortująca. Parametry funkcji zwracanej: * {{Code|tablica}} - tabela operowana, * {{Code|klucz}} - klucz, dzięki któremu szukamy następny element. Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> erm2yht1rqxtraq8imv25tq24s5tt9z 541340 541339 2026-04-30T05:50:51Z Persino 2851 /* {{Code|CzyTakSilnik(args,funkcja)}} */ 541340 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica, z główną tablicą, z elementami modyfikującymi elemenenty i je zmienione sprawdzające, a następnie dodające do nich przedrostki i przyrostki. Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów numerowanych, * {{Code|wartosc}} - wartość, którą wsadzamy jako ostatni element do tej tablicy. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko numerowanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu numerowanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko nienazwwanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu nienazwanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać, * {{Code|wartość}} - wartość tego klucza, jaką ta tabela powinna posiadać. Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}} i {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tabela elementów będących tabelami, * {{Code|args2}} - tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Parametry: * {{Code|tabela_1}} - tabela elementów, * {{Code|tabela_2}} - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args[1]}} - tabela elementów, * {{Code|args[2]}}, {{Code|args[3]}},... - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji, * {{Code|funkcja}} - funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, może być to funkcją, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica transportu ramki, * {{Code|czy_nie_tablica_jako_tablica}} - czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcji w nagłówku, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewną tablicę jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} - parametry logiczne dodatkowe funkcji. Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry: * {{Code|t}} - tablica, po której iterujemy po elemenetach numerowanych. Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, po której iterujemy, * {{Code|funkcja}} - funkcja sortująca. Parametry funkcji zwracanej: * {{Code|tablica}} - tabela operowana, * {{Code|klucz}} - klucz, dzięki któremu szukamy następny element. Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> kd4i0bma4zj01vzru2i429zmzrps24d 541341 541340 2026-04-30T06:16:41Z Persino 2851 /* {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} */ 541341 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica, z główną tablicą, z elementami modyfikującymi elemenenty i je zmienione sprawdzające, a następnie dodające do nich przedrostki i przyrostki. Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów numerowanych, * {{Code|wartosc}} - wartość, którą wsadzamy jako ostatni element do tej tablicy. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko numerowanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu numerowanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko nienazwwanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu nienazwanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać, * {{Code|wartość}} - wartość tego klucza, jaką ta tabela powinna posiadać. Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}} i {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tabela elementów będących tabelami, * {{Code|args2}} - tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej w {{Code|args2}}, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Parametry: * {{Code|tabela_1}} - tabela elementów, * {{Code|tabela_2}} - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args[1]}} - tabela elementów, * {{Code|args[2]}}, {{Code|args[3]}},... - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji, * {{Code|funkcja}} - funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, może być to funkcją, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica transportu ramki, * {{Code|czy_nie_tablica_jako_tablica}} - czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcji w nagłówku, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} - parametry logiczne dodatkowe funkcji. Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry: * {{Code|t}} - tablica, po której iterujemy po elemenetach numerowanych. Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, po której iterujemy, * {{Code|funkcja}} - funkcja sortująca. Parametry funkcji zwracanej: * {{Code|tablica}} - tabela operowana, * {{Code|klucz}} - klucz, dzięki któremu szukamy następny element. Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> c61v0wqm5yeqg6hrtl0ftzw6uhhyc6s 541342 541341 2026-04-30T06:46:00Z Persino 2851 /* {{Code|p["ŁączTabele"]()}} */ 541342 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica, z główną tablicą, z elementami modyfikującymi elemenenty i je zmienione sprawdzające, a następnie dodające do nich przedrostki i przyrostki. Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów numerowanych, * {{Code|wartosc}} - wartość, którą wsadzamy jako ostatni element do tej tablicy. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko numerowanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu numerowanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko nienazwwanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu nienazwanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać, * {{Code|wartość}} - wartość tego klucza, jaką ta tabela powinna posiadać. Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}} i {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tabela elementów będących tabelami, * {{Code|args2}} - tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je, jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Parametry: * {{Code|tabela_1}} - tabela elementów, * {{Code|tabela_2}} - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args[1]}} - tabela elementów, * {{Code|args[2]}}, {{Code|args[3]}},... - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji, * {{Code|funkcja}} - funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, może być to funkcją, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica transportu ramki, * {{Code|czy_nie_tablica_jako_tablica}} - czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcji w nagłówku, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} - parametry logiczne dodatkowe funkcji. Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry: * {{Code|t}} - tablica, po której iterujemy po elemenetach numerowanych. Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, po której iterujemy, * {{Code|funkcja}} - funkcja sortująca. Parametry funkcji zwracanej: * {{Code|tablica}} - tabela operowana, * {{Code|klucz}} - klucz, dzięki któremu szukamy następny element. Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 63orxqsx78rs9yhqkbxuk6c8hmnrra3 541345 541342 2026-04-30T06:58:43Z Persino 2851 541345 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzający, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji jest, pierwsze: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji jest, drugie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, trzecie: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji jest, czwarte: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica, z główną tablicą, z elementami modyfikującymi elemenenty i je zmienione sprawdzające, a następnie dodające do nich przedrostki i przyrostki. Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów numerowanych, * {{Code|wartosc}} - wartość, którą wsadzamy jako ostatni element do tej tablicy. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko numerowanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu numerowanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko nienazwwanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu nienazwanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać, * {{Code|wartość}} - wartość tego klucza, jaką ta tabela powinna posiadać. Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}} i {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tabela elementów będących tabelami, * {{Code|args2}} - tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je, jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Parametry: * {{Code|tabela_1}} - tabela elementów, * {{Code|tabela_2}} - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args[1]}} - tabela elementów, * {{Code|args[2]}}, {{Code|args[3]}},... - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji, * {{Code|funkcja}} - funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, może być to funkcją, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica transportu ramki, * {{Code|czy_nie_tablica_jako_tablica}} - czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcji w nagłówku, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} - parametry logiczne dodatkowe funkcji. Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry: * {{Code|t}} - tablica, po której iterujemy po elemenetach numerowanych. Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, po której iterujemy, * {{Code|funkcja}} - funkcja sortująca. Parametry funkcji zwracanej: * {{Code|tablica}} - tabela operowana, * {{Code|klucz}} - klucz, dzięki któremu szukamy następny element. Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 878cp34oq3w8lektsjd4mivkvev0x52 541346 541345 2026-04-30T07:09:35Z Persino 2851 /* Funkcje, czy są takie parametry */ 541346 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji, pierwsze, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji, drugie, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji, trzecie, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji, czwarte, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica, z główną tablicą, z elementami modyfikującymi elemenenty i je zmienione sprawdzające, a następnie dodające do nich przedrostki i przyrostki. Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Parametry: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów numerowanych, * {{Code|wartosc}} - wartość, którą wsadzamy jako ostatni element do tej tablicy. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko numerowanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu numerowanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów, nie tylko nienazwwanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu nienazwanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać, * {{Code|wartość}} - wartość tego klucza, jaką ta tabela powinna posiadać. Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}} i {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tabela elementów będących tabelami, * {{Code|args2}} - tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je, jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Parametry: * {{Code|tabela_1}} - tabela elementów, * {{Code|tabela_2}} - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry: * {{Code|args[1]}} - tabela elementów, * {{Code|args[2]}}, {{Code|args[3]}},... - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Parametry: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry: * {{Code|args}} - tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji, * {{Code|funkcja}} - funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, może być to funkcją, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica transportu ramki, * {{Code|czy_nie_tablica_jako_tablica}} - czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcji w nagłówku, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} - parametry logiczne dodatkowe funkcji. Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry: * {{Code|t}} - tablica, po której iterujemy po elemenetach numerowanych. Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry: * {{Code|tabela}} - tabela, po której iterujemy, * {{Code|funkcja}} - funkcja sortująca. Parametry funkcji zwracanej: * {{Code|tablica}} - tabela operowana, * {{Code|klucz}} - klucz, dzięki któremu szukamy następny element. Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> lkwzddgvqhuq7qutcimaod0rc05tvfe 541350 541346 2026-04-30T07:42:43Z Persino 2851 541350 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykładem wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji, pierwsze, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji, drugie, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji, trzecie, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji, czwarte, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica, z główną tablicą, z elementami modyfikującymi elemenenty i je zmienione sprawdzające, a następnie dodające do nich przedrostki i przyrostki. Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Parametry funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów numerowanych, * {{Code|wartosc}} - wartość, którą wsadzamy jako ostatni element do tej tablicy. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów, nie tylko numerowanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu numerowanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów, nie tylko nienazwwanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu nienazwanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać, * {{Code|wartość}} - wartość tego klucza, jaką ta tabela powinna posiadać. Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela1}} i {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tabela elementów będących tabelami, * {{Code|args2}} - tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je, jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela_1}} - tabela elementów, * {{Code|tabela_2}} - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args[1]}} - tabela elementów, * {{Code|args[2]}}, {{Code|args[3]}},... - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji, * {{Code|funkcja}} - funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, może być to funkcją, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica transportu ramki, * {{Code|czy_nie_tablica_jako_tablica}} - czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcji w nagłówku, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} - parametry logiczne dodatkowe funkcji. Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry funkcji: * {{Code|t}} - tablica, po której iterujemy po elemenetach numerowanych. Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, po której iterujemy, * {{Code|funkcja}} - funkcja sortująca. Parametry funkcji zwracanej: * {{Code|tablica}} - tabela operowana, * {{Code|klucz}} - klucz, dzięki któremu szukamy następny element. Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> tqik7ij9zucxu5uo817mvde35bsnsuo 541351 541350 2026-04-30T07:44:37Z Persino 2851 541351 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykład użycia: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji, pierwsze, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji, drugie, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji, trzecie, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji, czwarte, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica, z główną tablicą, z elementami modyfikującymi elemenenty i je zmienione sprawdzające, a następnie dodające do nich przedrostki i przyrostki. Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Parametry funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów numerowanych, * {{Code|wartosc}} - wartość, którą wsadzamy jako ostatni element do tej tablicy. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów, nie tylko numerowanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu numerowanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów, nie tylko nienazwwanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu nienazwanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać, * {{Code|wartość}} - wartość tego klucza, jaką ta tabela powinna posiadać. Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela1}} i {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tabela elementów będących tabelami, * {{Code|args2}} - tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je, jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela_1}} - tabela elementów, * {{Code|tabela_2}} - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args[1]}} - tabela elementów, * {{Code|args[2]}}, {{Code|args[3]}},... - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji, * {{Code|funkcja}} - funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, może być to funkcją, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica transportu ramki, * {{Code|czy_nie_tablica_jako_tablica}} - czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcji w nagłówku, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} - parametry logiczne dodatkowe funkcji. Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry funkcji: * {{Code|t}} - tablica, po której iterujemy po elemenetach numerowanych. Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, po której iterujemy, * {{Code|funkcja}} - funkcja sortująca. Parametry funkcji zwracanej: * {{Code|tablica}} - tabela operowana, * {{Code|klucz}} - klucz, dzięki któremu szukamy następny element. Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> r0en8ihycthdxubmybxfcfj2qdwjsws 541352 541351 2026-04-30T07:47:53Z Persino 2851 541352 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji, pierwsze, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji, drugie, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji, trzecie, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji, czwarte, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica, z główną tablicą, z elementami modyfikującymi elemenenty i je zmienione sprawdzające, a następnie dodające do nich przedrostki i przyrostki. Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Parametry funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. To wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Szablonu: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów numerowanych, * {{Code|wartosc}} - wartość, którą wsadzamy jako ostatni element do tej tablicy. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów, nie tylko numerowanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu numerowanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów, nie tylko nienazwwanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu nienazwanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać, * {{Code|wartość}} - wartość tego klucza, jaką ta tabela powinna posiadać. Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela1}} i {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tabela elementów będących tabelami, * {{Code|args2}} - tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je, jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela_1}} - tabela elementów, * {{Code|tabela_2}} - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args[1]}} - tabela elementów, * {{Code|args[2]}}, {{Code|args[3]}},... - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji, * {{Code|funkcja}} - funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, może być to funkcją, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica transportu ramki, * {{Code|czy_nie_tablica_jako_tablica}} - czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcji w nagłówku, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} - parametry logiczne dodatkowe funkcji. Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry funkcji: * {{Code|t}} - tablica, po której iterujemy po elemenetach numerowanych. Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, po której iterujemy, * {{Code|funkcja}} - funkcja sortująca. Parametry funkcji zwracanej: * {{Code|tablica}} - tabela operowana, * {{Code|klucz}} - klucz, dzięki któremu szukamy następny element. Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> be4peywb9vxphagj8uj9peptoasirj3 541354 541352 2026-04-30T08:15:01Z Persino 2851 541354 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Parametry}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} Moduł wywołuje się za pomocą polecenia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Moduł: {{ld2|Parametry}}, służy do operowania na wszelkiego rodzaju parametrach, modyfikowaniu ich, a nawet podawania z funkcji z tablicy ramki tablicy transportu tego modułu, i innych funkcji z innych modułów, które wykorzystują funkcje parametru tego modułu. Będziemy mówili, że zbiór jest ponumerowany, gdy ma elementy nienazwane od jeden zwyż, bez przerw, do pewnego końca, wtedy jest to sekwencja w języku {{lpg|Lua}}, a jeżeli ona nie jest ponumerowana, to ma tylko elementy nienazwane, czyli wtedy nie jest sekwencją. Zbiór z elementami nienazwanymi (nazwane liczbami naturalnymi) może zawierać czasami elementy nazwane, ktorego nazwy nie są już takie, zwykle je się oznacza łańcuchami znakowymi, a w języku {{lpg|Lua}} to są po prostu elementy typu: {{Code|string}}, a liczby naturalne typu: {{Code|number}}. == Funkcje liczb elementów w tabeli == === {{Code|p["LiczbaElementówNumerowanychTablicy"]()}} === Funkcja liczy liczbę numerowanych elementów tablicy od {{Code|1}}, one nie mogą mieć miedzy sobą przerw zaczynające się właśnie od niej, czyli: {{Code|1,2,3,4,...}}. Można podać, czy oczekujemy wartości tylko niepustych, czy nie. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, jeżeli {{Code|true}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, jeżeli {{Code|true}}. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={["nazwa1","nazwa2","nazwa3","nazwa4","nazwa5","nazwa6","nazwa7","nazwa8","nazwa9",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNumerowanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|9}}, ponieważ ma on mnóstwo parametrów nienazwanych, które jednocześnie są numerowane, czyli są one od {{Code|1}} i ciągną się bez przerw, aż do pewnej liczby. Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych. === {{Code|p["LiczbaElementówNumerowanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNumerowanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. <syntaxhighlight lang="lua"> p["LiczbaElementówNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji ramki tablicy transportu, które z dwóch odpowiadają parametrom: {{Code|wliczac}} i {{Code|mnoga}}, wykorzystywanej funkcji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ta zmienna niepusta, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusta. Odpowiednikiem zmiennej {{Code|tabela}}: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawionym niepustym parametrem mnogości, wtedy ona powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaElementówNumerowanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwaa2|nazwa3|nazwa4|nazwa5|nazwa6|nazwa7|nazwa8|nazwa9}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów numerowanych niepustych, tzn. gdy ten parametr jest podany od, a elementy tam są od {{Code|1}}, bez przerw, a jeżeli są przerwy, jeżeli taki przykład sformułować, to do jej pierwszej, a w tym przypadku nie ma takich. Powyższa funkcja zrzuca wynik wyliczony, a ponieważ ustawiony został parametr mnogości w dziecku tego szablonu, wtedy zwraca liczbę {{Code|2}}, a gdyby nie był, to zobaczylibyśmy liczbę tych elementów. Jak można zauważyć, że ma on parametry numerowane (zaczynające się od jedynki), które można znaleźć w parametrach szablonu, jeżeli tam w ogóle istnieją. === {{Code|p["LiczbaElementówNienazwanychTablicy"]()}} === Funkcja liczy liczbę nienazwanych elementów niekoniecznie od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą, nie zawsze, mieć przerwy, np. mogą być podane tak: {{Code|3,10,15,..}}. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, w tym przypadku, a jeżeli nie jest taka, to zrzucony wynik jest {{Code|0}}, {{Code|1}}, ale nie {{Code|2}}). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychTablicy"]=function(tabela, wliczac,mnoga)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, ma wartosć nieodpowiadająca {{Code|false}}, * {{Code|mnoga}} - czy liczba tych numerowanych elementów jest mnoga, wartość jak powyżej. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={[2]="nazwa1",[10]="nazwa2",[15]="nazwa3",[18]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_tablicy=parametry_modul["LiczbaElementówNienazwanychTablicy"](tabela,true,false); </syntaxhighlight> Wynik tej funkcji jest {{Code|4}}, bo taka jest liczba parametrów nienazwanych, ale nie numerowanych. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych. === {{Code|p["LiczbaParametrówNienazwanychSzablonu"](frame)}} === Funkcja wywoływana w ramce w wikikodzie, wykorzystująca funkcję z definicji: {{Code|{{sr|#p["LiczbaElementówNienazwanychTablicy"]()|p=Parametry}}}}, i robiąca to samo, co ona, tylko wykorzystywana na innym poziomie, tzn. jako wywołana ramka w szablonie, a nie powinna być uruchamiana w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaParametrówNienazwanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametrami funkcji tablicy ramki, odpowiedniki parametrów: {{Code|wliczac}} i {{Code|mnoga}} funkcji wykorzystywanej z definicji, są kolejno: * {{Code|niepuste}} - czy szukamy niepuste elementy numerowane parametrów szablonu, w którym ta ramka została wywołana, w postaci tej funkcji, jeżeli ten argument niepusty, * {{Code|mnoga}} - czy liczba takich wyszukań jest mnoga, jeżeli niepusty. Odpowiednikiem parametru {{Code|tabela}} jest: * {{Code|frame:getParent().args}} - czyli parametry szablonu rodzica, policzona za pomocą tablicy ramki, jej funkcji, tablicy transportu. Funkcje wywołuje się w ramce w szablonie, jako dziecko, w postaci, np., gdy rozważamy parametry niepuste szablonu, z ustawieniem parametrem mnogości, wtedy funkcja ta powinna zwrócić liczbę {{Code|0}}, {{Code|1}} lub {{Code|2}}: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|LiczbaParametrówNienazwanychSzablonu|niepuste=tak|mnoga=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=nazwa1|10=nazwa2|15=nazwa3|18=nazwa4}} </syntaxhighlight> Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych w liczbie mnogie, tzn. gdy ten parametr jest podany. Powyższa funkcja zrzuca wynik wyliczony, ze względu to ustawienie w dziecku, jako liczbę {{Code|2}}. === {{Code|p["LiczbaElementówTablicy"]()}} === Funkcja liczy liczbę nienazwanych (numerowanych) i nazwanych elementów tablicy, a jeżeli parametr: {{Code|wliczac}}, jest podany, to liczy elementy, które nie są nie o zawartości niepustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela do rozważań na problemy tej funkcji, * {{Code|wliczac}} - czy ma liczyć liczbę elementów niepustych, jeżeli {{Code|true}}. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={ 10, nazwa = 5, parametr = "tak", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_tablicy=parametry_modul["LiczbaElementówTablicy"](tabela,true); </syntaxhighlight> Policzona liczba elementów {{Code|liczba_elementow_tablicy}} jest {{Code|3}}. Powyższa funkcja liczy liczbę wszystkich parametrów niepustych w podanej tablicy. === {{Code|p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]()}} === Funkcja liczy liczbę nienazwanych od {{Code|1}}, ale mogą zaczynać się od pewnej liczby, mogą między sobą mieć przerwy, np.: {{Code|3,10,15,..}}, liczbę elementów tablicy odpowiednio skonstruowanych, charakterystycznych dla tej funkcji. Można podać, czy oczekujemy wartości tylko niepustych. Można wskazać, czy liczba elementów jest mnoga (większa od {{Code|1}}, ale równa {{Code|2}}, a jeżeli nie jest taka, to wtedy {{Code|0}} lub {{Code|1}}). Należy też podać niepusty przedrostek, niebędący liczbą zakodowaną w łańcuchu. Należy wskazać funkcji, czy oczekujemy formy numerkowe, ale nie muszą to być liczby, ale mogą być one łańcuchami numerkowymi, a jezeli nie są takie, to one muszą być w postaci czystych liczb, a w przypadku form, które po przekształceniu na liczbę funkcją {{Code|tonumber}} stają się normalnymi liczbami {{lpg|Lua}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"]=function(tabela,przedrostek,wliczac,czy_formy_numerkowe)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, na którym operujemy, * {{Code|przedrostek}} - niepusty, niebędący liczbą łańcuchową, przedrostek, który ma być przed liczbą, * {{Code|wliczac}} - czy szukamy niepuste elementy numerowane tabeli, * {{Code|czy_formy_numerkowe}} - czy wyszukiwane liczby przy pomocy funkcji {{Code|pairs}}, czy są czystymi liczbami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja liczy liczbę parametrów nienazwanych i nazwanych, ale z podanym przedrostkiem, lub nie, skonstruowanych z tych pierwszych. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela={[2]="wartość1", [10]="wartosć2", [15]="wartość3", ["18"]="wartość4", ["nazwa2"] = "wartosc5", ["nazwa10"] = "wartość6", ["nazwa18"] = "wartość7", }; local parametry_modul=require("Module:Parametry"); local liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy=parametry_modul["LiczbaElementówNienazwanychZPrzedrostkiemLubNieTablicy"](tabela,"nazwa",true,false); </syntaxhighlight> Funkcja w postaci wartości {{Code|liczba_elementow_nienazwanych_z_przedrostkiem_lub_nie_w_tablicy}} zwróci liczbę {{Code|7}}. Powyższe wywołanie liczy liczbę parametrów nienazwanych niepustych, z przedrostkiem lub nie, ale nie czysto numerkowych, ale również numerkowych (szeregi). == Funkcje minimalnej i maksymalnej wartości w tabeli == === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje, jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w którym on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MaksymalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|10=nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik {{Code|20}}, ponieważ ta nazwa (klucz) parametru jest największa. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MaksymalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy maksymalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie, przerwy, nie zawsze zaczynający się od jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, w nim elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local maksymalna_wartosc_parametru_nienazwanego=parametry_modul.MaksymalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|maksymalna_wartosc_parametru_nienazwanego}} równej: {{Code|20}}. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoSzablonu(frame)}} === Funkcja wywołana w ramce szablonu, który może nawet liczyć, i nie tylko, parametry niepuste, jeżeli to w nim wskazano w ramce dziecka szablonu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MaksymalnaLiczbaParametruNienazwanegoSzablonu=function(frame)...end; </syntaxhighlight> Funkcja ma parametry, które przyjmuje jako parametry dziecka ramki, też zbiera zmienne rodzica: * {{Code|niepuste}} - niepuste, wtedy w liczy tylko elementy szablonu niepuste, tylko je wykorzystuje do rozważań, * {{Code|frame:getParent().args}} - parametry szablonu rodzica dziecka ramki, w której on został wywołany. Przykład wywołania ramki dziecka w szablonie rodzica jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|MinimalnaLiczbaParametruNienazwanegoSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|4=nazwa1|5=nazwa2|150nazwa3|20=nazwa4}} </syntaxhighlight> Szablon zrzuci liczbę {{Code|4}}, ponieważ ta nazwa parametru najmniejsza. Funkcja wykorzystuje do swojego działania: {{Code|{{sr|#p.MinimalnaLiczbaParametruNienazwanegoTablicy()}}}}, który robi to samo, co podana funkcja, tylko jest inne obrazowanie zmiennych. === {{Code|p.MinimalnaLiczbaParametruNienazwanegoTablicy()}} === Funkcja liczy minimalny numer parametru nienazwanego, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się od jedynki, nie zawsze zaczynający się jedynki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.MinimalnaLiczbaParametruNienazwanegoTablicy=function(tabela, wliczac)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|wliczac}} - czy ma uwzględniać w swoich rozważaniach, podczas liczenia podanej tabeli, jego elementy niepuste. Przykładem wywołania jest dla parametrów niepustych tablicy: <syntaxhighlight lang="lua"> local tabela={[4]="nazwa1",[5]="nazwa2",[10]="nazwa3",[20]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc_parametru_nienazwanego=parametry_modul.MinimalnaLiczbaParametruNienazwanegoTablicy(tabela,true); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrze: {{Code|minimalna_wartosc_parametru_nienazwanego}} równej: {{Code|4}}. === {{Code|p.MinimalnyIMaksymalnyNumerParametru()}} === Funkcja liczy minimalny i maksymalny numer parametru nazwanego numerowany ze spację liczbami naturalnymi, może być od {{Code|0}}, określony liczbą, mający w sobie, niekoniecznie mający przerwy, nie zawsze zaczynający się jedynki, elementów o pewnej podstawie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.MinimalnyIMaksymalnyNumerParametru(tabela,nazwa_parametru_okreslona)...end; </syntaxhighlight> Funkcja ma zmienne, które przyjmuje w wywołaniu funkcyjnym: * {{Code|tabela}} - rozważana tabela, podana jako pierwszy argument funkcji, * {{Code|nazwa_parametru_okreslona}} - podstawa parametrów numerowanych, np. mogący być: {{Code|nazwa 1}}. Przykładem wywołania jest dla parametrów o nazwach niepustych w tablicy: <syntaxhighlight lang="lua"> local tabela={["nazwa 4"]="tak",["nazwa 5"]="tak",["nazwa 10"]="tak",["nazwa 20"]="tak",}; local parametry_modul=require("Module:Parametry"); local minimalna_wartosc,maksymalna_wartosc=parametry_modul.MinimalnyIMaksymalnyNumerParametru(tabela,"nazwa"); </syntaxhighlight> Funkcja zwróci wynik o wartości, w parametrach: {{Code|minimalna_wartosc}} i {{Code|maksimum_wartosc}}, mający kolejno wartości liczbowe: {{Code|4}} i {{Code|20}}. Jest to minmalna i maksymalna wartość dla liczb po spacji siedzące przy podstawach parametrów, która jest podana w parametrze drugim funkcji. == Funkcje, czy są takie parametry == Poniższe funkcje zwracają {{Code|tak}} w ramce szablony, w przypadku wersji szablonowych, a typowp funkcyjnych {{Code|true}}, gdy coś znaleziono, gdy nic, to wartość języka {{lpg|Lua}}, czyli: {{Code|nil}}, w drugim przypadku, co odpowiada w odpowiednikach uruchamianych w ramce szablonu wartości pustej {{Code|""}}, lub {{Code|false}}, w tym drugim przypadku. === {{Code|p["CzySąParametryNumerowaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy numerowane, tzn. od {{Code|1}} bez przerw, ale z końcem, lub do jej pierwszej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNumerowaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy numerowane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ istnieją jakieś parametry numerowane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNumerowaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNumerowaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy numerowane tablicy, tzn. numerowane od {{Code|1}} bez przerw, ale z końcem, lub do pierwszej przerwy. Można wskazać, są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNumerowaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy numerowane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={"nazwa1", "nazwa2", "nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_numerowane_tablicy=parametry_modul["CzySąElementyNumerowaneTablicy"](table,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo istnieją jakieś elementy numerowane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametryNienazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane, tzn., niekoniecznie od {{Code|1}} mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowwa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNienazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania jest, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNienazwaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=nazwa1|5=nazwa2|8=nazwa3}} </syntaxhighlight> Funkcja ramki w szablonie zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nienazwane, a nienumerowane (nie zaczyna się od {{Code|1}}). Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNienazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNienazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}} są elementy nienazwane, tzn. nienazwane, niekoniecznie od {{Code|1}}, mogący być z przerwami, ale z końcem. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNienazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy nienazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={[3]="nazwa1", [5]="nazwa2", [8]="nazwa3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane=parametry_modul["CzySąElementyNienazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ma on jakieś parametry nienazwane tablicy {{Code|tabela}}, a nienumerowane (nie zaczyna się od {{Code|1}}). === {{Code|p["CzySąParametryNazwaneSzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametryNazwaneSzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametryNumerowaneSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|10=wartość2|15=wartość3}} </syntaxhighlight> Szablon zwróci wynik {{Code|tak}}, ponieważ ma on jakieś parametry nazwane. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyNazwaneTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyNazwaneTablicy"]()}} === Funkcja służy do wskazania, czy w tablicy {{Code|tabela}}, są elementy nazwane, tzn. niemający klucza w postaci liczby naturalnej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyNazwaneTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartośc3", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nazwane=parametry_modul["CzySąElementyNazwaneTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ są jakieś elementy nazwane tabeli {{Code|tabela}}. === {{Code|p["CzySąParametrySzablonu"](frame)}} === Funkcja służy do wskazania, czy w parametrach szablonu rodzica, w której jest uruchomiona ta funkcja w postaci ramki, są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąParametrySzablonu"] = function(frame)...end; </syntaxhighlight> Parametry ramki szablonu, sprawdzające, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|niepuste}} - czy ma uwzględniać parametry tylko niepuste, * {{Code|frame:getParent().args}} - tablica do rozważań przez funkcję biblioteczną. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzySąParametrySzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość4|2=nazwa4|6=nazwa6}} </syntaxhighlight> Funkcja ramki szablonu zwroci wynik {{Code|tak}}, ponieważ ma on jakieś parametry. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzySąElementyTablicy"]()|p=Parametry}}}}, do obsługi ramki w szablonie, którą wywołuje się w wikikodzie. === {{Code|p["CzySąElementyTablicy"]()}} === Funkcja służy do wskazania, czy w parametrach tabeli {{Code|tabela}} są elementy nienazwane lub nazwane, tzn. elementy niemający klucza w postaci liczby naturalnej i łańcuchowej. Można wskazać, czy są takie te elementy niepuste za pomocą dodatkowego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzySąElementyTablicy"]=function(tabela,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy są elementy nienazwane lub nazwane, ewentualnie niepuste: * {{Code|tabela}} - tabela do rozważań, * {{Code|wliczać}} - czy ma uwzględniać parametry niepuste w tabeli {{Code|tabela}}. Wywołanie przykładowej tej funkcji jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1", ["nazwa2"]="wartość2", ["nazwa3"]="wartość3", [2]="nazwa4", [6]="nazwa5", }; local parametry_modul=require("Module:Parametry"); local czy_sa_elementu_nienazwane_lub_nazwane=parametry_modul["CzySąElementyTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, ponieważ ta tabela {{Code|tabela}} ma jakieś elementy. === {{Code|p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"](frame)}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w parametrach szablonu rodzica, w której jest wywołana ta funkcja ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyParametrSzablonu"] = function (frame)...end; </syntaxhighlight> Parametry funkcji sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|niepuste}} - taki element nie może być pusty, * {{Code|frame:getParent().args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie. Przykładem wywołania, gdy rozważamy parametry niepuste szablonu, ewentualnie niepuste, jest: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyCoNajwyżejJedenNumerowanyParametrSzablonu|niepuste=tak}} </syntaxhighlight> Szablon, w którym jest wywołane to przedstawienie, można napisać w wynikach poniżej. Przykład pierwszy: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik {{Code|tak}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Przykład drugi: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|1=nazwa2|nazwa3=6|3=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane. Przykład trzeci: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6|4=nazwa4}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo są dwa elementy nienazwane, ale one nie zaczynają się od {{Code|1}}, dlatego wynik jest przede wszystkim taki. Przykład czwarty: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=5|2=nazwa2|nazwa3=6}} </syntaxhighlight> Szablon zrzuci wynik równy wartości pustej {{Code|""}}, bo nie ma parametrów numerowanych zaczynających się od liczby {{Code|1}}. Funkcja wykorzystuje funkcję: {{Code|{{sr|#p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()|p=Parametry}}}}, do obsługi tej funkcji ramki, którą wywołuje się w wikikodzie. === {{Code|p["CzyCoNajwyżejJedenNumerowanyElementTablicy"]()}} === Funkcja sprawdza, czy element numerowany jest od jedynki, i czy jest on jeden wśród parametrów nienazwanych w podanej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyCoNajwyżejJedenNumerowanyElementTablicy"] = function (args,wliczac)...end; </syntaxhighlight> Parametry funkcji, sprawdzające, czy jest jeden element numerowany funkcji: * {{Code|args}} - tabela ramki szablonu rodzica, wśród, w której następuje to wyszukiwanie, * {{Code|wliczac}} - taki element nie może być pusty. Wywołanie przykładowej tej funkcji, pierwsze, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6,}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik {{Code|true}}, bo liczba elementów numerowanych jest {{Code|1}}, i nie ma dalszych elementów nienazwanych. Wywołanie przykładowej tej funkcji, drugie, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [1]="nazwa2", ["nazwa3"]=6, [3]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji, trzecie, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, [4]="nazwa4",}; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, ale, są dwa elementy nienazwane. Wywołanie przykładowej tej funkcji, czwarte, jest: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]=5, [2]="nazwa2", ["nazwa3"]=6, }; local parametry_modul=require("Module:Parametry"); local czy_jest_co_najwyżej_jeden_element_numerowany=parametry_modul["CzyCoNajwyżejJedenNumerowanyElementTablicy"](tabela,true); </syntaxhighlight> Funkcja zrzuci wynik równy wartości {{Code|false}}, bo nie ma pierwszego elementu numerowanego, tzn. dla parametru {{Code|tabela[1]}}, mimo, że jest jeden element nienazwany. == Funkcje kopiowania tabel == === {{Code|p["KopiujTabelęŁańcuchów"]()}} === Szablon przyjmuje tabelę: {{Code|args}}, którego elementem jest: {{Code|args.tabela}}, która jest tą właściwą tabelę, na której operujemy. Tabela {{Code|args}} posiada składowe do zastępowania poszczególnych elementów w niej, a jeżeli nie ma dla niego składowych szczególnych, to rzeczywiście kopiujemy tabelę łańcuchów, w przeciwnym wypaadku, ją modyfikujemy. Z tak uzyskanej tabeli wyodrębniamy pewne elementy, modyfikujemy je, lub po pewnych operacjach odejmujemy, i tworzymy nowa tabelę. A jeśli w niej uzyskiwanej, to do niego dodawjemy elementy przedrostkiem i przyrostkiem, a podstawie tego tworzymy nową tabelę {{Code|args2}}, która zwracana jest przez tę funkcję. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęŁańcuchów"]=function(args)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica, z główną tablicą, z elementami modyfikującymi elemenenty i je zmienione sprawdzające, a następnie dodające do nich przedrostki i przyrostki. Składowymi nazwanymi tabeli: {{Code|args}}, którym koniecznym elementem jest {{Code|args.tabela}}, a dalsze są opcjonalne, ale tylko co najmniej jeden z nich musi być podany, co na podstawie, z której tworzymy nową tabelkę, a więc: * {{Code|args.tabela}} - tabela, na której operujemy, na podstawie, z której tworzymy zwracaną tabelę {{Code|args2}}, * {{Code|args["wzór"][coś]}} lub {{Code|args["wzór wszystko"]}} - wzór wyszukiwania, czy element wskazywany przez niego, ma to, * {{Code|args.podstawienie[coś]}} lub {{Code|args["podstawienie wszystko"]}} - podstawienie, dokonane po znalezieniu elementu w elemencie według powyższego zaraz wzoru, i go zastąpienie, * {{Code|args["wzór 2"][coś]}} lub {{Code|args["wzór wszystko 2"]}} - wzór wyodrębnienia pewnej części, jeśli element to ma po ewentualnym podstawieniu, a jeśli tego nie ma, to zwracane jest {{Code|nil}}, wtedy z tego elementu tabeli, dla której uzyskaliśmy tę wartość, nie jest przetwarzana jako element nowej tabeli {{Code|args2}}, * {{Code|args.przedrostek[coś]}} lub {{Code|args["przedrostek wszystko"]}} - jeśli element istnieje wyszukany powyższym wzorem, to to jest przedrostek przed tym elementem, * {{Code|args.przyrostek[coś]}} lub {{Code|args["przyrostek wszystko"]}} - jeśli element istnienie wyszukany powyższym wzorem, to to jest przyrostek po tym elemencie. Element {{Code|coś}} jest to jakiś klucz elementu tabeli {{Code|args.tabela}}. W powyższych alternatywach jest sprawdzany najpierw pierwszy element alternatywny, czy istnieje, a potem drugi. Za pomocą tego modyfikujemy tę tabelę lub usuwamy poszczególne jego elementy, tworząc tabelę {{Code|args2}}. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; local args = { tabela = tabela, ["wzór wszystko"] = "%d+$", ["podstawienie wszystko"] = "_numer", ["wzór wszystko 2"] = "_numer$", ["przedrostek wszystko"] = "coś przed ", ["przyrostek wszystko"] = " coś po", }; local args2 = parametry_modul["KopiujTabelęŁańcuchów"](args); mw.logObject(args2, "Uzyskana tabela:" ); </syntaxhighlight> Uzyskaną tabelą jest w wyniku operacji według powyższego kodu, wyświetlaną przez funkcję {{Code|mw.logObject}} jest: <syntaxhighlight lang="lua"> local args2={ [1] = "coś przed wartość_numer coś po", [2] = "coś przed wartość_numer coś po", ["nazwa1"] = "coś przed wartość_numer coś po", ["nazwa2"] = "coś przed wartość_numer coś po", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementów"]()}} === To jest nierekurencyjne kopiowanie tabeli {{Code|tabela}}, a jeżeli {{Code|wliczac_1{{=}}true}}, to klucze elementów nie mogą być puste lub wskazywać na wartość fałszywą, a jeśli {{Code|wliczac_2{{=}}true}}, to wartości tych elementów o tych kluczach nie mogą być puste lub wskazywać na wartość fałszywą. W takim przypadku wywoływana w takim bądź razem jest funkcja: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametrami funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul = require("Module:Parametry"); local tabela = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabela2 = parametry_modul["KopiujTabelęElementów"](tabela,true,true); </syntaxhighlight> Uzyskana tabela {{Code|tabela2}} jest w wyniku wywołania kodu, którą możemy podejrzeć przy pomocy funkcji: {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabela2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", }; </syntaxhighlight> === {{Code|p["KopiujTabelęElementówBezTablicyKluczy"]()}} === Funkcja kopiuje nierekurencyjnie elementy tabeli {{Code|tabelka}}, usuwając z niej elementy o kluczach wskazanych przez tabelę {{Code|tabelka2}}, którego elementy piszemy w postaci {{Code|{"klucz"] {{=}} "wartość"}}. Funkcją wyszukiwującą klucze w tabeli {{Code|tabelka2}} jest: {{Code|{{sr|#p.CzyJestTakiKluczTabeli()|p=Parametry}}}}. Z tabeli można usunąć klucze, ewentualnie przy pomocy {{Code|wliczac_1{{=}}true}}, jeśli chodzi o klucze, i ewentualnie wartości {{Code|wliczac_2{{=}}true}}, a tutaj o wartości, o wartościach pustych lub fałszywych uzyskiwanej z funkcji: {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujTabelęElementówBezTablicyKluczy"]=function(tabelka,tabelka2,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|tabelka2}} - tabela zbudowana przy pomocy ściśle określonych kluczy o dowolnych wartościach (wartości są nieistotne), za pomocą których usuwamy elementy tabeli {{Code|tabelka2}}, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykłady usuwania kluczy z tabeli o kluczach i wartościach, pustych lub fałszywych (określoną wartością {{Code|false}}): <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={ [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = ""}; local tabelka2={[2]=true,["nazwa2"]=false,}; local tabelka3=parametry_modul["KopiujTabelęElementówBezTablicyKluczy"](tabelka,tabelka2,true,true); </syntaxhighlight> Tabelą uzyskaną z wyników: {{Code|tabelka3}}, jest, którą możemy podejrzeć przy pomocy funkcji {{Code|mw.logObject}}: <syntaxhighlight lang="lua"> local tabelka3={ [1] = "wartość1", ["nazwa1"] = "wartość3", }; </syntaxhighlight> === {{Code|p["KopiujRekurencyjnieTabelęElementów"]()}} === Funkcja dokładnie rekurencyjnie kopiuje tabelę {{Code|tabelka}}, pomijając ewentualnie elementy o kluczach, przy pomocy {{Code|wliczac_1{{=}}true}}, i o wartościach przy pomocy: {{Code|wliczac_2{{=}}true}}, przy użyciu funkcji. Funkcja też kopiuje dokładnie również metafunkcje, na razie to jest przygotowane tylko dla jednych z nich, tzn. ona jest zdefiniowana {{ld2|Szablonowe/Potrzebne}}, i nazwana jest ona jako: {{Code|{{sr|#p.MetaTabelkaSzablonowe(__metatablica)|p=Szablonowe/Potrzebne}}}}, w niej musi istnieć składowa tej metatablicy o kluczu {{Code|tablica}}, w której są przechowywane elementy o jakiś kluczach i ich wartościach, właściwa do niego tabela jest zawsze pusta, a ta tabela należąca do metatabelki powiązana z tą tabelą natomiast nie ona taka, ona jest wykorzystywana do liczenia elementów. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["KopiujRekurencyjnieTabelęElementów"]=function(tabelka,wliczac_1,wliczac_2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Parametry funkcji: * {{Code|tabelka}} - tabela elementów o kluczach i ich wartościach, na której dokonujemy operacji, * {{Code|wliczac_1}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych kluczy, * {{Code|wliczac_2}} - jeśli {{Code|true}}, tabela {{Code|tabelka}} jest tworzona bez pustych lub fałszywych wartości o pewnych kluczach. Przykładem kopiowania rekurencyjnego tabeli {{Code|tabelka}}, usuwając z niej jednocześnie klucze i wartości, puste lub fałszywe, jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", [""] = "wartość5". ["nazwa3"] = "",["nazwa4"] = { ["nazwa5"}=true, ["nazwa6"] = "", }, }; local tabelka2=parametry_modul["KopiujRekurencyjnieTabelęElementów"](tabelka,true,true); </syntaxhighlight> Wynikiem jest dokładnie przekopiowana tabela {{Code|tabelka}} bez pewnych elementów: <syntaxhighlight lang="lua"> local tabelka2 = { [1] = "wartość1", [2] = "wartość2", ["nazwa1"] = "wartość3", ["nazwa2"] = "wartość4", ["nazwa4"] = {["nazwa5"] = true, }, }; </syntaxhighlight> Obiekt referencyjny {{Code|tabelka2}}, jest ona dokładną kopioną pierwotnej jej wersji, wskazuje na inny adres niż {{Code|tabelka}}. == Funkcje istnienia parametrów == === {{Code|p["NazwanyLiczbą"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyLiczbą}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nienazwany parametr, tzn. określony liczbą. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyLiczbą"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyLiczbą|2}} </syntaxhighlight> Wywołanie szablonu z tą ramką jako dziecko: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|2=wartość|3=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo znalazł parametr nienazwany {{Code|2|, ale nie numerowany. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p["NazwanyCiągiem"](frame)}} === Wywołanie ramki {{Code|{{m|Parametry|NazwanyCiągiem}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano taki nazwany parametr, tzn. określony łańcuchem znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwanyCiągiem"] = function (frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|NazwanyCiągiem|nazwa1}} </syntaxhighlight> Wywołanie szablonu z tą ramką jako dziecko: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość|nazwa2=wartość}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nazwane parametry, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nazwane(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nazwane|nazwa1|nazwa2|nazwa3}} </syntaxhighlight> Wywołanie szablonu z tą ramką jako dziecko: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry, tzn. o kluczach {{Code|nazwa1}} i {{Code|nazwa2}} posiadający wartości, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Nienazwane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Nienazwane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie nienazwane parametry (oznaczone liczbami naturalnymi) o wartościach takich jak, tzn. określone łańcuchami znaków. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Nienazwane(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Nienazwane|wartość1|wartość2|wartość3}} </syntaxhighlight> Wywołanie szablonu z tą ramką jako dziecko: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|3=wartość1|6=wartość2}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry nienazwane o wartościach takich, tzn. {{Code|wartość1}} i {{Code|wartość2}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Nienazwane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. === {{Code|p.Numerowane(frame)}} === Wywołanie ramki {{Code|{{m|Parametry|Numerowane}}}} umieszcza się w szablonie rodzicu, sprawdza, czy w szablonie podano takie numerowane parametry, tzn. określone łańcuchami znaków: Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Numerowane(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|Numerowane|wartość1|wartość2|wartość3}} </syntaxhighlight> Wywołanie szablonu z tą ramką jako dziecko: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|wartość2|wartość3}} </syntaxhighlight> Wtedy funkcja (ramka) w szablonie zwróci wartość {{Code|tak}}, bo w szablonie są dwa takie parametry numerowane (tzn. numerowane od jedynki bez przerw) o wartościach takich, tzn. {{Code|wartość2}} i {{Code|wartość3}}, które są podzbiorem z trzech wartości według funkcji ramki {{Code|{{m|Parametry|Numerowane}}}}. Funkcje wywołuje się tylko w postaci ramki, a nie w skrypcie {{lpg|Lua}} w {{lpr|Scribunto}}, bo tam istnienie parametru sprawdza się innymi metodami. == Funkcje manipulowania formatów łańcuchów znakowych == === {{Code|p["Odstępy"](frame)}} === ==== Odpowiednik szablonowy ==== Odpowiednik szablonowy {{s|Odstępy}} ma te same parametry, co jej odpowiednik ramkowy funkcyjny: {{Code|{{m|Parametry|Odstępy}}}}. Przykładami wywołania funkcji: Poniższe przykłady są pokazane przy pomocy szablonu {{s|Pre}}. ; Przykład pierwszy {{Pre|{{s|Odstępy| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz już nie. ---- ; Przykład drugi {{Pre|{{s|Odstępy|wewnątrz{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony spacją. ---- ; Przykład trzeci {{Pre|{{s|Odstępy|wewnątrz{{=}}tak|dolny-myślnik{{=}}tak| Oto jest łańcuch. }}}} ; Wynik {{Pre|{{Odstępy|wewnątrz=tak|dolny-myślnik=tak| Oto jest łańcuch. }}}} Widzimy, że odstępy na końcach łańcucha zostały usunięte, a wewnątrz łańcucha każdy odstęp został zastąpiony na dolny myślnik. ==== Funkcja biblioteczna ==== Funkcja usuwa białe znaki i dolne myślniki na końcach podanego ciągu, ale też ewentualnie można przy pomocy tej funkcji zamieniać też te znaki wewnątrz ciągu, o ile nie jest już pusty po poprzedniej operacji, i zamienia ich na jedną spację lub dolny myślnik. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Odstępy"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|nazwa}} - określa podany ciąg, któremu domyślnie są usuwane białe znaki lub dolne myślniki na końcach łańcucha, * {{Code|2}} lub {{Code|wewnątrz}} - czy ma również robić te same operacje, co powyżej domyślną, tylko że wewnątrz ciągu, * {{Code|3}} lub {{Code|dolny-myślnik}} - czy ma zamieniać, spacje i dolne myślniki (jeżeli je wykrywa, patrz parametr poniżej), na dolne myślniki, * {{Code|4}} lub {{Code|spacje}} - czy na końcach i wewnątrz ciągu ma wykrywać, do zamieniania, tylko odstępy, a nie również dolne myślniki. Funkcja zwraca przekształcony ciąg powyższymi metodami. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local nazwa2=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ",}; local nazwa3=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",}; local nazwa4=parametry_modul["Odstępy"]{nazwa=" Oto jest łańcuch. ", ["wewnątrz"]="tak",["dolny-myślnik"]="tak",}; </syntaxhighlight> Od pierwszego do trzeciego przykładu w naszym wypadku funkcja ta zwróci wartości: <syntaxhighlight lang="lua"> local nazwa2="Oto jest łańcuch."; local nazwa3="Oto jest łańcuch."; local nazwa4="Oto_jest_łańcuch."; </syntaxhighlight> == Funkcje dodawania lub usuwania elementu do tabeli zbioru == === {{Code|p.DodajElementDoZbioru()}} === Funkcja dodaje element do zbioru, czyli do tablicy numerowanej: {{Code|tabela}}, wartość: {{Code|wartość}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DodajElementDoZbioru(tabela,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów numerowanych, * {{Code|wartosc}} - wartość, którą wsadzamy jako ostatni element do tej tablicy. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={}; --- Tutaj zwraca true; local tak1=parametry_modul.DodajElementDoZbioru(tabela,"wartość1"); --- Tutaj zwraca true; local tak2=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); --- Tutaj zwraca false; local tak3=parametry_modul.DodajElementDoZbioru(tabela,"wartość2"); </syntaxhighlight> Elementami tej tabeli są: <syntaxhighlight lang="lua"> local tabela={"wartość1","wartość2",}; </syntaxhighlight> Funkcja zbiera tylko niepowtarzające się wartości, w tym wypadku zwraca wartość {{Code|true}}, w przeciwnym wypadku {{Code|false}}. == Funkcje istnienia elementów tabeli == === {{Code|p.CzyJestTakiElementNumerowanyTabeli()}} === Funkcja sprawdza, czy jest taki element numerowany. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNumerowanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów, nie tylko numerowanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu numerowanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niemający przerw, zaczynający się o kluczu od jedynki, ale z końcem, lub do pierwszej przerwy, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi od jedynki bez przerw z końcem na końcu. Przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={"wartość1","wartość2","wartość3",5,8,"wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNumerowanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementNienazwanyTabeli()}} === Funkcja sprawdza, czy jest taki element nienazwany, niekoniecznie numerowany. Ta tabela może mieć przerwy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementNienazwanyTabeli(tabela,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów, nie tylko nienazwwanych, * {{Code|wartosc}} - parametr wartości, jaką ta tablica powinna posiadać w postaci elementu nienazwanego. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie, nienazwanych, dla której sprawdzamy, czy jakiś element jego o kluczu określonej liczbą naturalną, czy posiada podaną wartość {{Code|wartość}}. Zaużmy, że tabelą naszą jest obiekt zdefiniowany z elementami numerowanymi niekoniecznie od jedynki mogący być z przerwami z końcem na końcu. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={[2]="wartość1",[5]="wartość2",[10]="wartość3",[80]=5,[90]=8,[100]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementNienazwanyTabeli(tabela,"wartość3"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiKluczTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu o dowolnej wartości. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiKluczTabeli(tabela,klucz)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać. Parametrami funkcji jest tabela {{Code|tabela}} elementów, niekoniecznie nazwanych, dla której sprawdzamy, czy jakiś element jego o danym kluczy {{Code|klucz}}, o dowolnej wartości. Zaużmy, że naszą tabelą jest tabela elementów nazwanych z kluczami i przydzielonymi im wartościom. <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiKluczTabeli(tabela,"nazwa5"); </syntaxhighlight> Funkcja w przykładzie zwraca wartość {{Code|true}}. === {{Code|p.CzyJestTakiElementTabeli()}} === Funkcja sprawdza, czy jest taki element o danym kluczu {{Code|klucz}} i wartości {{Code|wartość}} dla elementów w danej tabeli. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.CzyJestTakiElementTabeli(tabela,klucz,wartosc)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela elementów z kluczami i ich wartościami, * {{Code|klucz}} - klucz, jaką ta tabela musi posiadać, * {{Code|wartość}} - wartość tego klucza, jaką ta tabela powinna posiadać. Parametrami funkcji jest tabela {{Code|tabela}} o parametrach niekoniecznie nazwanych, ale on równie dobrze może składać się z elementów nienazwanych lub tylko numerowanych. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]=5,["nazwa5"]=8,["nazwa6"]="wartość4",}; local czy_tak=parametry_modul.CzyJestTakiElementTabeli(tabela,"nazwa5",8); </syntaxhighlight> Funkcja tutaj zwraca wartość {{Code|true}}. == Łączenie wielu tabel == === {{Code|p["ŁączDwieTabele"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane jak i nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączDwieTabele"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela1}} i {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączDwieTabele"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNumerowanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy ponumerowane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNumerowanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNumerowanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNienazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nienazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNienazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela1}}, {{Code|tabela2}} - tabele do połączenia w jedną tablicę. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNienazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryElementówNazwanychDwóchTabel"]()}} === Funkcja łączy dwie tabele przy pomocy funkcji: {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}}, które tam są ustawione w sposób ponumerowany, natomiast te tabele zawierają elementy nazwane. Te elementy tych tabel łączymy ze sobą, w ten sposób powstanie wynikowa tabela końcowa. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryElementówNazwanychDwóchTabel"]=function(tabela1,tabela2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryElementówNazwanychDwóchTabel"](tabela1,tabela2); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNienazwanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNienazwanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=false,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykłady użycia: <syntaxhighlight lang="lua"> local tabela1={"wartość1","wartość2","wartość3","wartość4",}; local tabela2={"wartość5","wartość6","wartość7","wartość8","wartość9",}; local tabela3={"wartość10","wartość11","wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNumerowanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Funkcja łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=false,CzyTylkoNazwaneElementyTabel=false,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={[2]="wartość1",[4]="wartość2",[7]="wartość3",[8]="wartość4",}; local tabela2={[3]="wartość5",[10]="wartość6",[12]="wartość7",[15]="wartość8",[16]="wartość9",}; local tabela3={[1]="wartość10",[7]="wartość11",[9]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNienazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={"wartość1","wartość2","wartość3","wartość4","wartość5","wartość6","wartość7","wartość8","wartość9","wartość10","wartość11","wartość12",}; </syntaxhighlight> === {{Code|p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone w pewien ściśle określony sposób. Funkcja łączy tylko elementy nazwane tabel, tabel ponumerowanych, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączZbioryNazwanychElementówNumerowanychTabel"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączZbioryNazwanychElementówNumerowanychTabel"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",}; </syntaxhighlight> === {{Code|p["ŁączNumerowaneTabele"]()}} === Funkcja wykorzystuje funkcję: {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele ponumerowane, które są pod zmienną {{Code|args}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączNumerowaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=false,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={tabela1,tabela2,tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNumerowaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączNienazwaneTabele"]()}} === Funkcja wykorzystuje funkcję {{Code|{{m|Parametry|ŁączTabele}}}}, którą nigdy się nie implemetuje w postaci ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, ale jako funkcję biblioteczną. Te tabele są łączone dokładnie w taki sposób, aby elementy się nie powtarzały, i elementy w nowo powstałej tabeli są powtórzeniem elementów w podanych tabeli z dokładnościa do tej informacji. Funkcja łączy tabele określone liczbami naturalnymi, które są pod zmienną {{Code|args}}. Definicja skrótowa fukcji: <syntaxhighlight lang="lua"> p["ŁączNienazwaneTabele"]=function(args) local parametry_modul=require("Module:Parametry"); local args2={CzyPairsTablic=true,["CzyPairsElementówTablic"]=true,CzyNazwaneElementyTabel=true,CzyTylkoNazwaneElementyTabel=false,NazwijElementyNumerowane=true,}; return parametry_modul["ŁączTabele"](args,args2); end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów będących elementami. Przykładem działania funkcji jest: <syntaxhighlight lang="lua"> local tabela1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",}; local tabela2={["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",}; local tabela3={["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; local args={[2]=tabela1,[10]=tabela2,[13]=tabela3,}; local parametry_modul=require("Module:Parametry"); local tabela_polaczona=parametry_modul["ŁączNienazwaneTabele"](args); </syntaxhighlight> Uzyskaną tabelą w wyniku wywołania tej funkcji jest: <syntaxhighlight lang="lua"> local tabela_polaczona={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",["nazwa5"]="wartość5",["nazwa6"]="wartość6",["nazwa7"]="wartość7",["nazwa8"]="wartość8",["nazwa9"]="wartość9",["nazwa10"]="wartość10",["nazwa11"]="wartość11",["nazwa12"]="wartość12",[2]="wartość13",[4]="wartość14",[7]="wartość15",[8]="wartość16",[3]="wartość17",[10]="wartość18",[12]="wartość19",[15]="wartość20",[16]="wartość21",[1]="wartość22",[7]="wartość23",[9]="wartość24",}; </syntaxhighlight> === {{Code|p["ŁączTabele"]()}} === Funkcja łączy tabele ogólnie nazwane, określone w tablicy {{Code|args2}}, względem parametrów określonych w tablicy {{Code|args2}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ŁączTabele"] = function(args,args2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tabela elementów będących tabelami, * {{Code|args2}} - tablica z kluczami o wartościach {{Code|true}}, jeśli to ustawienie włączone, w przeciwnym wypadku wyłączone. Funkcja łączy jedynie tabele ponumerowane liczbami naturalnymi, czy to w sposób nienazwany, też za pomocą tych liczb, ale wtedy numeracja nie musi być od jedynki i ona może mieć przerwy. Parametry (elementy) tabeli {{Code|args2}} są: * {{Code|args2.CzyPairsTablic}} - jeśli prawdziwa, to określa nazwane elementy tabel w tabeli, w przeciwnym wypadku numerowane, * {{Code|args2["CzyPairsElementówTablic"]}} - jeśli prawdziwa, to określa nazwane elementy poszczególnych tabel w tablicy ogólnie nazwanej, w przeciwnym wypadku numerowane, * {{Code|args2.CzyNazwaneElementyTabel}} - jeśli prawdziwe, łączy nazwane elementy tabel, mogą być określone liczbami naturalnymi, lub nie, w jedną tablicę, * {{Code|args2.CzyTylkoNazwaneElementyTabel}} - jeśli niepuste, łączy tylko nazwane elementy tabel, * {{Code|args2.NazwijElementyNumerowane}} - jeśli prawdziwe, to wśród elementów nienazwanych elementy numerowane traktuje je, jako nazwane, w przeciwnym wypadku takie elementy dodaje do zbioru elementów numerowanych łączonych tablic. Przykładami wykorzystania tej funkcji są funkcje łączenia tabel zdefiniowane w funkcjach powyżej, tzn. zdefiniowane w: * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy ponumerowane elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - laczy nazwane tylko liczbami naturalnymi elementy tabel, tabel nazwanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNienazwanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel określonych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNumerowanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy ponumerowane tabel, tabel ponumerowanych liczbami naturalnymi, * {{Code|{{sr|#p["ŁączZbioryNienazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy elementy nazwane tylko liczbami naturalnymi tabel, tabel ponumerowanych, * {{Code|{{sr|#p["ŁączZbioryNazwanychElementówNumerowanychTabel"]()|p=Parametry}}}} - łączy tylko elementy nazwane tabel, tabel ponumerowanych. Powyższe funkcje elementy nienazwane łączy w zbiory, ale nie jako elementy nazwane, tylko jako ponumerowane. {{Hr}} * {{Code|{{sr|#p["ŁączNumerowaneTabele"]()|p=Parametry}}}} - łączy tabele ponumerowane, * {{Code|{{sr|#p["ŁączNienazwaneTabele"]()|p=Parametry}}}} - łączy tabele określone liczbami naturalnymi. Powyższe funkcje łączą w sposób dokładny wiele tabel, niezależnie z jak nazwanymi elementami, te nazwane jest nie tylko określone liczbami naturalnymi (one nie muszą być ponumerowane), ale też łańcuchami. {{Hr}} Działanie tych funkcji w powyższej wyliczance można rozszyfrować na podstawie ich nazw podanych w nawiasach kwadratowych w cudzysłowach. == Funkcje dodawania lub usuwania elementów z tabeli o takich kluczach == === {{Code|p["UsuńElementyTabeli"]()}} === Funkcja w tabelce {{Code|tabelka_1}} usuwa elementy, którego klucze są w {{Code|tabelka_2}}, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńElementyTabeli"]=function(tabelka_1,tabelka_2)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela_1}} - tabela elementów, * {{Code|tabela_2}} - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabelka_koncowa=parametry_modul["UsuńElementyTabeli"](tabelka_1,tabelka_2); </syntaxhighlight> Stworzona w ten sposób tabelka {{Code|tabelka_koncowa}}, to ma taką referencję, co {{Code|tabelka_1}}, ale za to ma elementy, jako: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> Ta pierwotna tabela została zmodyfikowana przy pomocy tej funkcji według tego przykładu. == Tworzenie tabeli == === {{Code|p["TwórzTabelęBezPowtarzającychKluczyTabel"]()}} === Funkcja jest analogiem do funkcji {{Code|{{sr|#p["UsuńElementyTabeli"]()|p=Parametry}}}}, dla jednej tabeli, a ta funkcja jest dla wielu. Funkcja w tabelce {{Code|args[1]}} przy pomocy, której z niej tworzymy elementy, usuwa, tworząc nową tabelę, elementy, którego klucze są w tabelach o numerach większych od jedynki, któremu wartości przyporządkowane są obojętne, byle tylko, by nie były jako {{Code|nil}}. Najprościej gadając, wartości moją mieć w drugiej tabelce wartość {{Code|true}}, ale nie muszą takie być. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["TwórzTabelęBezPowtarzającychKluczyTabel"]=function(args)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args[1]}} - tabela elementów, * {{Code|args[2]}}, {{Code|args[3]}},... - tabele, co za pomocą ich kluczy są usuwane elementy z tej pierwszej. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka_1={["nazwa1"]="wartość1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",["nazwa4"]="wartość4",}; local tabelka_2={["nazwa1"]=true,["nazwa3"]=true,}; local tabela_args={tabelka_1,tabelka_2,}; local tabelka_koncowa=parametry_modul["TwórzTabelęBezPowtarzającychKluczyTabel"](tabelka_args); </syntaxhighlight> Stworzona w ten sposób tabelka: {{Code|tabelka_koncowa}}, nie ma takiej samej referencji, co: {{Code|tabelka_1}}, tylko inną, a więc nie modyfikujemy pierwotnej tej pierwzsej tabeli, tylko tworzymy nową, ale ma za to elementy: <syntaxhighlight lang="lua"> local tabelka_koncowa={["nazwa2"]="wartość2",["nazwa4"]="wartość4",}; </syntaxhighlight> == Funkcje typu == === {{Code|p.TypeTable()}} === Funkcja sprawdza, czy typem zmiennej jest tabela w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrotowa funkcji: <syntaxhighlight lang="lua"> function p.TypeTable(zmienna) return (type(zmienna)=="table"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabelka={"wartość1","wartosc2",["nazwa1"]="wartość3",} local czy_tak=parametry_modul.TypeTable(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeFunction()}} === Funkcja sprawdza, czy typem zmiennej jest funkcja w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeFunction(zmienna) return (type(zmienna)=="function"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local funkcja=function(frame)return true;end; local czy_tak=parametry_modul.TypeFunction(funkcja); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeString()}} === Funkcja sprawdza, czy typem zmiennej jest łańcuch znakowy w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeString(zmienna) return (type(zmienna)=="string"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local str="wartość"; local czy_tak=parametry_modul.TypeString(tabelka); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeBoolean()}} === Funkcja sprawdza, czy typem zmiennej jest typ logiczny w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeBoolean(zmienna) return (type(zmienna)=="boolean"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_jest_tam=false; local czy_tak=parametry_modul.TypeBoolean(czy_jest_tam); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNumber()}} === Funkcja sprawdza, czy typem zmiennej jest liczba w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNumber(zmienna) return (type(zmienna)=="number"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local liczba=2; local czy_tak=parametry_modul.TypeNumber(liczba); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> === {{Code|p.TypeNil()}} === Funkcja sprawdza, czy typem zmiennej jest zmienna z przydzieloną wartością, której jest {{Code|nil}}, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TypeNil(zmienna) return (type(zmienna)=="nil"); end; </syntaxhighlight> Parametry funkcji: * {{Code|zmienna}} - parametr, którego chcemy sprawdzić, czy pasuje do ściśle określonego typu według funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_nil=nil; local czy_tak=parametry_modul.TypeNil(czy_nil); -- Wartością zmiennej: czy_tak, jest: true; </syntaxhighlight> == Funkcje prawdy i fałszu == W funkcjach: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, uruchomione w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, muszą posiadać dodatkowo parametr {{Parametr|wyspecjalizowana|tak}}, aby dało się w je wsadzić skutecznie parametry do samej tej ramki dziecka, a nie używać parametry szablonu rodzica. W tej pierwszej funkcji jest wykorzystywana na druga, w której w tej pierwszej w parametrze pierwszym, w przypadku łańcuchów znakowych wykorzystywana jesy funkcja do usuwania dolnych myślników i odstępów na końcach, a potem jest uruchamiana ta druga. Te funkcje rozwazane tutaj powiedziane powyżej w wikikodzie w szablonie rodzicu, czy w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, służą do sprawdzenia, czy wartość, czy jest nierówna ciągowi uzyskanemu pustemu, w przypadku tej pierwszej funkcji, a w przypadku drugiej, czy jest ciągiem pustym, a jeżeli jest to liczba, to czy jest nie równa {{Code|0}}, czy wartością logiczną jest jako {{Code|true}}, w przypadku tabel, czy jest niepustą tabelą, ale za to w funkcji, czy funkcja o nazwie {{Code|zmienna}} z parametrami {{Code|parametry}}, czy zwraca wartość odpowiadająca {{Code|true}}, jeżeli tak, to ta funkcja zwróci znak {{Code|tak}}, w przeciwnym wypadku w wikikodzie zwraca wartość pustą, a w kodzie wartość {{Code|nil}}. === {{Code|CzyTakSilnik(args,funkcja)}} === Funkcja pomocnicza służąca do liczenia wartości logicznej {{Code|tak}} lub {{Code|nil}} parametrów ramki, w wikikodzie, funkcji {{lpg|lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function CzyTakSilnik(args,funkcja)...end; </syntaxhighlight> Parametry funkcji: * {{Code|args}} - tablica elementów z pierwszym elementem do sprawdzenia, z drugim jako nazwa modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w takim przypadku ten pierwszy element jest nazwą funkcji, który w połączeniu z nazwą modułu daje referencję do funkcji, * {{Code|funkcja}} - funkcja, za pomocą której sprawdzamy logiczność pierwszego elementu tej tablicy. Możliwymi wartościami funkcji parametru {{Code|funkcja}} jest {{Code|CzyTak}} lub {{Code|CzyTakCiąg}} (ta funkcja wykorzystuje funkcję {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} do swojego argumentu, który służy do sprawdzania, jaki spełnia warunek). Gdy istnieje parametr tablicy {{Code|args}} funkcji o parametrze nienazwanym {{Code|args[2]}}, który jest nazwą modułu z funkcjami {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a samą funkcją jest {{Code|args[1]}}, to tak utworzona funkcja jest zmienną {{Code|parametr}}, ma jeżeli jej nie ma, to ona przyjmuje wartość {{Code|args[1]}}, a gdy jednak istnieje ten drugi element, to na podstawie którego zbierane są argumenty ramki nazwane jak nazwane, tzn. klucze i ich wartości przypisuje, a w przypadku parametrów nienazwanych (nie są zbierane elementy w tej tablicy o kluczach o wartości: {{Code|1}} i {{Code|2}}), a te inne klucze są pomniejszane o dwa, w ten sposób jest utworzona tabela {{Code|argsfun}}. Gdy nie ma składowej drugiej tablicy, tzn. {{Code|args[2]}}, to wtedy funkcja sprawdza, czy {{Code|args[1]}} to jest liczba w łańcuchu znakowym, lub bezpośrednio liczba, a jeżeli nie da się jej przetransformować na liczbę, to sprawdza, czy typem tej zmiennej jest {{Code|string}} (czy typem jest szereg), po działaniu funkcją: {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, jeśli ma wtedy wartość: {{Code|"true"}}, wtedy ta rozważana na samym początku zmienna przyjmuje wartość {{Code|true}}, {{Code|"false"}}, wtedy {{Code|false}}, {{Code|"nil"}}, wtedy {{Code|nil}}. A jeżeli ta zmienna żadnej tej wartości nie przyjmuje z tych wartości, to wtedy jest transformowana na liczbę, jeżeli da się tą operację dokonać. Na samym końcu jest liczona wartość logiczna z przygotowanymi parametrami, według jednej z dwóch specjalnie przygotowanych funkcji w postaci wywołania ogólnego: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); return (parametry_modul[funkcja]{[1]=parametr,[2]=argsfun,})and "tak" or nil; </syntaxhighlight> Gdzie {{Code|funkcja}}, to {{Code|CzyTak}} lub {{Code|CzyTakCiąg}}, a {{Code|parametr}}, to funkcja w jakimś module lub inna wartość, a {{Code|argsfun}}, to tabela argumentów ramki, dziecka, w kodzie {{lpg|Lua}} w {{lpr|Scribunto}}, w wikikodzie w szablonie rodzicu. Gdy ta funkcja zwróci wartość logiczną odpowiadającą {{Code|true}}, to wtedy zwraca {{Code|tak}}, w przeciwnym wypadku {{Code|nil}}. Ta funkcja jest wykorzystywana, gdy jest uruchamiana w ramce, gdy mamy parametry ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wyspecjalizowana=tak}} </syntaxhighlight> Podobnie jest z funkcją {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. A jak jest tworzony parametr zmiennej z powyższych wywołań, to jest powiedziane powyżej. Równie dobrze możemy zefiniować atrapę funkcji {{Code|frame.getParent}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"]{args={ [1]=" Wartość ", [2]="", ["nazwa1"]="wartość1", ["nazwa2"]="wartość2", [3]="wartość3", [4]="wartość4", ["wyspecjalizowana"]="tak", }, getParent=function()end, }; </syntaxhighlight> Czasami tak potrzeba robić, by ominąc zabezpieczenia pewnych funkcji, nawet tutaj. === {{Code|p["CzyTakCiąg"](...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}} i {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyTakCiąg"]=function(...)...end; </syntaxhighlight> Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, a w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTakCiąg| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi pustemu, mimo że funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}} zwróci wartość {{Code|tak}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul["CzyTakCiąg"](" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|nil}}. === {{Code|p.CzyTak(...)}} === W tej funkcji parametry mogą być zbierane w osobnych parametrach lub w jednej tablicy albo ta funkcja może być uruchomiona w ramce. Funkcja do swojego działania nie wykorzystuje do tego {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, tak jak to robi {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.CzyTak=function(...)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|zmienna}} - sprawdzana zmienna, może być to funkcją, * {{Code|2}} lub {{Code|parametry}} - parametry funkcji, może być to tablica parametrów, jest ona wykorzystywana, gdy powyższy element jest funkcją. Jeżeli ta funkcja jest uruchomiona w ramce, np. w postaci: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| Wartość |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość {{Code|tak}}, tak jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} A w przypadku: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak| |wyspecjalizowana=tak}} </syntaxhighlight> To w tym przypadku funkcja zwraca wartość równą ciągowi {{Code|tak}}, mimo że funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}} zwróci wartość równoważną ciągowi pustemu. <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|CzyTak||wyspecjalizowana=tak}} </syntaxhighlight> Ta funkcja uruchomiona w ramce w wikikodzie zwraca wartość równą ciągowi pustemu, tak samo, jak funkcja {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}. Podobnie jest w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, czyli: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" Wartość "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(" "); </syntaxhighlight> Ta funkcja zwróci wartość {{Code|tak}}, niezależnie, czy tym ciągiem jest szereg składający się z samych znaków odstępów. A teraz inny przykład: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local czy_tak=parametry_modul.CzyTak(""); </syntaxhighlight> Ta funkcja wtedy zwróci wartość równą {{Code|nil}} w kodzie {{lpg|Lua}} w {{lpg|Lua|Scribunto}}. == Funkcje parametrów == === {{Code|p.PobierzFrameEwentualnieParent(frame)}} === Argument tej funkcji {{Code|frame}} koniecznie musi być tablicą, w przypadku przeciwnym wywoła to błąd języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzFrameEwentualnieParent(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej, którą jest {{Parametr|wyspecjalizowana|tak}}. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(frame).args; .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzFrameEwentualnieParent(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdy by funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu jest taka niedogodność, że jedynie jest taka nieprawidłowość, że w przypadku parametru tablicy ramki tablicy transportu należy podawać uzyskanej element {{Code|args}}, a w przypadku zwykłej tablicy już nie, tą niedokodność rozwiązuje funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. === {{Code|p.PobierzArgsParametry(frame,...)}} === Argument tej funkcji {{Code|frame}} koniecznie nie musi być tablicą, bo wtedy nie wywoła to błędu języka {{lpg|Lua}}, że z wartości nietabelowej chcemy wyliczyć jego niepusty element {{Code|getParent}}, bo przedtem sprawdzana jest w tej funkcji, czy jest to tablica. W definicji tej funkcji zmienna uzyskana z funkcji: {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}, a jeśli jej składowa {{Code|args}} jest tablicą, to jest właśnie ona zwracana, a jeśli istnieje, ale nie jest tablicą, lub ona nie istnieje, to wtedy brana jest właśnie wartość tablicowa {{Code|frame}}, jeśli jest ona taka, a gdy nie, to wtedy z tej funkcji tutaj nie korzystamy. Funkcja pobiera parametry ramki szablonu rodzica, a nie dziecka, a jeżeli w dziecku w ramce w wikikodzie w szablonie podamy specjalny parametr {{Parametr|wyspecjalizowana|tak}}, to wtedy ta funkcja ściąga parametry ramki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzArgsParametry(frame, czy_nie_tablica_jako_tablica)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica transportu ramki, * {{Code|czy_nie_tablica_jako_tablica}} - czy wartości nietablicowe umieszczać w jednoelemenowej tabeli. Funkcja wykorzystuje wspomnianą powyżej funkcję do swojego działania, ona jest wtedy aktywowana, gdy zmienna {{Code|frame}} jest tablicą, i jest sprawdzane, czy ona posiada nazwany element o kluczu {{Code|args}}, i czy jest on tablicowy. Jeżeli wartością zmiennej {{Code|frame}} nie jest tablica, ale nie przybiera wartości {{Code|nil}}, to ona jest umieszczana w tablicy, jeżeli zmiennej {{Code|czy_nie_tablica_jako_tablica}} przydzielimy wartość {{Code|true}}, w przeciwnym wypadku zwracana jest ona w postaci niezmienionej, a jeżeli wartość tej zmiennej nie istnieje, to zwracana jest zwykła tablica pusta. Tą funkcją można sterować ze strony ramki tym właśnie specjalnym parametrem o wartości niepustej. W ramce podajemy argumenty wraz z tym specjalnym parametrem: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> To wtedy w kodzie w {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w module o nazwie {{Code|Nazwa modułu}}, piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame); .... end; </syntaxhighlight> To wtedy w kodzie ściągane parametry ramki dziecka. Tę funkcję można równie dobrze wykorzystać do zwykłych tabel: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(tabela); </syntaxhighlight> A w tym przypadku ta funkcja nic nie robi, tylko zmienna {{Code|args}} referencyjnie wskazuje na tablicę {{Code|tablica}}. Ale można ją wykorzystać, gdyby funkcja {{Code|Nazwa funkcji}}, była uruchomiona ze zwykłą tablicą, ale z możliwością, że to może być tablicą ramki {{Code|frame}} tablicy transportu, np.: <syntaxhighlight lang="lua"> --- Pierwsza możliwość; local wartosc1=p["Nazwa funkcji"](frame); -- Druga możliwość local wartosc2=p["Nazwa funkcji"]{["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; </syntaxhighlight> Dla obu tych przypadków nie ma żadnej niedogodności, jak to występowała w {{Code|{{sr|#p.PobierzFrameEwentualnieParent(frame)|p=Parametry}}}}. Jeśliby do funkcji tablicy transportu dać wartość równą nie tablicy, to wtedy równoważnie możemy napisać: <syntaxhighlight lang="lua"> local wartosc="wartość"; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> to wtedy definicję tej funkcji piszemy: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); local wartosc=args[1]; end; </syntaxhighlight> lub równoważnie możemy zapisać: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); local wartosc=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> A jeżeli nie wsadziliśmy żadnej wartości do funkcji ramki tablicy transportu lub tą wartością jest {{Code|nil}}, wtedy: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](); </syntaxhighlight> wtedy definicja tej funkcji wygląda: <syntaxhighlight lang="lua"> local p={}; function p["Nazwa funkcji"](frame) local parametry_modul=require("Module:Parametry"); -- Zmienna: args, wskazuje na wartość, którą jest tablicą pustą, tzn. w tej tablicy nie ma wcale elementów; local args=parametry_modul.PobierzArgsParametry(frame); end; </syntaxhighlight> Widzimy, że wtedy zmienna {{Code|args}} jest normalną pustą tablicą, i nie musimy wtedy wcale pisać poniżej, bo wtedy wychodzi w tym przypadku na to samo: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local args=parametry_modul.PobierzArgsParametry(frame,true); </syntaxhighlight> Argument drugi w {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, który w naszym przypadku musi mieć wartość {{Code|true}}, a wtedy jest jedynie sens, gdy {{Code|frame}} nie jest tablicą, i gdy chcemy tą wartość umieścić w tablicy, a nie powtórzyć wartość, tzn. chcemy napisać: {{Code|{{(}}frame,{{)}}}}, w przeciwnym wypadku musilibyśmy napisać coś w rodzaju, zamiast tak spreparowanej tablicy: {{Code|frame}}, czyli: <syntaxhighlight lang="lua"> -- Pierwszy przypadek, gdy frame jest wartością nietablicową; local parametry_modul=require("Module:Parametry"); ... -- Zwracana wartość: args, to nic innego niż: {frame,}; local args=parametry_modul.PobierzArgsParametry(frame,true); ... -- Zwracana wartość: args, to nic innego niż: frame, a nie {frame,}, jak poprzednio; local args=parametry_modul.PobierzArgsParametry(frame); </syntaxhighlight> === {{Code|p.PobierzParametryRamki(frame)}} === Funkcja służy do ustawienia pewnych domyślnych dwóch pewnych funkcji służących do pobieranie danych z tabelki z pierwszej tej funkcji, jeżeli ona posiada klucz o wartości {{Code|args}}, to zwracana jest ta właśnie tablica jako argument pierwszej tej funkcji, jeżeli jest w ogóle tablicą, w przeciwnym wypadku zwracana jest ta oryginalna tablica też jako argument tej funkcji, w przeciwnym dalszym wypadku zwracana jest zwracana wartość ta jako argument tej drugiej funkcji, która zwraca prawdziwą wartość z argumentu tylko za pierwszym razem, z tej funkcji, za następnym i dalszym razem {{Code|nil}}. Z tak utworzonej ogólnie większej funkcji wykorzystywana jest w budowie funkcji w nagłówku, która jest zwracana przez funkcję w tym nagłówku, która względem jego budowy wywołuje raz pierwszą albo drugą poprzednią wspomnianą funkcję zależną od rodzaju tabeli {{Code|frame}}. Ta funkcja zwracana przez funkcję w nagłówku przyjmuje argument, która jest kluczem do tych wspomnianych tabel (dokładnie, która tabelka to zależy od formatu tej naszej rozważanej zmiennej), a jeżeli to nie tabelka, co jest zwracane, to już zostało powiedziane. Definicja skrótowa tej funkcji jest: <syntaxhighlight lang="lua"> function p.PobierzParametryRamki(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy ramkę sformułowaną w wikikodzie jako dziecko w szablonie rodzicu: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy tablica ramki tablicy transportu posiada właśnie {{Code|frame}}, która jest tablicą, i na pewno posiada tablicę o nazwie {{Code|args}}, to wtedy tę funkcję wywołaną w ramce, która wywołuje funkcję w nagłówku, formułujemy: <syntaxhighlight lang="lua"> local p={}; local p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); ... end; </syntaxhighlight> Równie dobrze funkcję z ramki można wywołać w sposób, co wtedy ta funkcja też zostanie wywołana pozytywnie: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}}; </syntaxhighlight> W tej funkcji nie trzeba definiować funkcji fałszywej {{Code|getParent}}, w postaci: {{Code|getParent{{=}}function()end}}. Widzimi, że ta tablica posiada nazwę zmiennej tablicowej o nazwie {{Code|args}}, ale ona nie jest tablicą ramki tablicy transportu, ale tą tablicę możemy bezposrednio wsadzić w tą główną tablicę w samym argumencie funkcji. Równie dobrze możemy wywołać tę funkcję zdefiniowaną naszą w jakimś module w sposób: <syntaxhighlight lang="lua"> local tabela={["nazwa1"]="wartość1",["nazwa2"]="wartość2","wartość3",}; local wynik=p["Nazwa funkcji"]{tabela); </syntaxhighlight> też ta funkcja prawidłowo się wywoła. W tym przypadku, jak i w przypadkach powyżej, wyniki uzyskuje się w następującym wywołaniach: <syntaxhighlight lang="lua"> --- Zmienna: wartosc1, przyjmuje wartość: "wartość1"; local wartosc1=PobierzParametryRamki("nazwa1"); --- Zmienna: wartosc2, przyjmuje wartość: "wartość2"; local wartosc2=PobierzParametryRamki("nazwa2"); --- Zmienna: wartosc3, przyjmuje wartość: "wartość3"; local wartosc3=PobierzParametryRamki(1); </syntaxhighlight> W innym przypadku wywołań funkcji ramki jest wsadzenie do niej zwykłego nietablicowego elementu, może być też to wartość: {{Code|nil}}. A to wywołanie jest: <syntaxhighlight lang="lua"> local wartosc="wartość"; --Zmienna: wartosc, nie jest w tym przypadku tablicą; local wynik=p["Nazwa funkcji"](wartosc); </syntaxhighlight> Wtedy w tej ramce w celu uzyskania jakikolwiek wartości jest przykład wywołania tej funkcji zwracanej przez funkcję w ramce z argumentem pustym. <syntaxhighlight lang="lua"> -- Zmienna: wartość1, przyjmuje wartość: "wartość"; Jeżeli ona, przyjmuje wartość: nil, to wywołanie rzuci: nil, i za każdym następny razem; local wartosc1=PobierzParametryRamki(); -- Zmienna: wartość2, przyjmuje wartość: nil; local wartosc2=PobierzParametryRamki(); </syntaxhighlight> W wywołaniach powinno dbać się o właściwą kolejność wywołań, bo argumentem funkcji z tablicy transportu może być zwykła tablicowa wartość. Najpierw uzyskujemy wartości nietablicowe, a później tablicowe, na wypadek niewiadomej {{Code|frame}} jakiego typu ma być wartość. Też ta zmienna może istnieć pod kilkoma możliwymi kluczami, lub tą zmienną może być jedyny argument funkcji, która jest nietablicową wartością, wtedy ją się wywołuje jako dla przypadku, gdy parametr jest nietablicowy lub jest pod kluczem {{Code|tekst}}: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)("tekst"); </syntaxhighlight> Lub chcemy tę funkcję wywołać bezparametrowo, gdy chcemy, by {{Code|frame}} nie była tablicą: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tekst=parametry_modul.PobierzParametryRamki(frame)(); </syntaxhighlight> Wtedy ta zmienna w przedostatnim przykładzie jest pod wartością {{Code|tekst}}, gdy wartość {{Code|frame}} jest tablicą, lub może być jedyną wartością, którą jest {{Code|frame}} jako zmienna nietablicowa, wtedy ta zmienna też jest pod {{Code|tekst}}, ta funkcja uzyskana z: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}, wtedy może być wywołana tylko raz z nienilową wartością zwracaną, następnym razem zwraca wartość {{Code|nil}}, wtedy to dotyczy przedostatniego i ostatniego przykładu. Jeżeli {{Code|frame}} jest nietablicowa, to wtedy wartość {{Code|tekst}} jest taka sama, co {{Code|frame}}. A jeżeli jest tablicą, to ta wartością jest {{Code|frame.args["tekst"]}}, lub gdy {{Code|args}} nie istnieje, lub istnieje, ale jest nietablicowa, to wtedy ta wartość jest {{Code|frame["tekst"]}}. A gdy zmienne istnieją pod wieloma kluczami, lub gdy funkcję wywołano ze zmienną nietablicową, wtedy ogólnie możemy dla przykładu powiedzieć: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametryRamki=parametry_modul.PobierzParametryRamki(frame); local wartosc1=PobierzParametryRamki("nazwa1") or PobierzParametryRamki(1); local wartosc2=PobierzParametryRamki("nazwa2") or PobierzParametryRamki(2); local wartosc3=PobierzParametryRamki("nazwa3") or PobierzParametryRamki(3); </syntaxhighlight> Wtedy ta zmienna jest pod kluczem, np.: {{Code|nazwa1}} lub {{Code|1}}, tablicy ramki {{Code|frame}} tablicy transportu, następne wywołania dla następnych kluczy też zrzucą pewne wartości, lub jest ona zwykłą nietablicową wartością mogącą być równą nawet {{Code|nil}}. Następne wywołania uzyskanej tak funkcji w przypadku, gdy {{Code|frame}} jest nietablicowy, rzucać będzie z samej definicji funkcji wartości {{Code|nil}}, czyli {{Code|wartosc2{{=}}wartosc3{{=}}nil}}, ale za to wartość {{Code|wartosc1}} nie musi być, ale może, wartością {{Code|nil}}, jest tą wartością, gdy {{Code|frame{{=}}nil}}, w przeciwnym wypadku za pierwszym razem tej wartości nietablicowej uzyskamy wartość nie {{Code|nil}}, a za drugim i dalszym zawsze wartość {{Code|nil}}. === {{Code|p.PobierzElementNumerowanyZFrameLubTablicy(frame)}} === Definicja skrótowa funkcji jest z parametrem charakteryzującym pewien zestaw zmiennych {{Code|frame}}, które nie jest tablicą ramki tablicy transportu, tylko innym parametrem, który jest tablicą parametrów podanych do funkcji, nawet gdy parametrem podanym do funkcji, w której wykorzystujemy tą funkcję, jest jedyna zmienna będąca tablicą ramki, ale z drugiej strony tak nie musi być, może być to rozbudowany zestaw zmiennych, np. nazwanych i nienazwanych, którego wszystkie sposoby podawania łączymy jednym sposobem podawania. Mimo że parametry funkcji są parametrami nienazwanymi, mogą być one ponumerowane, ale zmienna w tablicy może przyjmować wartość tą samą na różne sposoby, raz w sposób nazwany, a za innym sposobem jako nienazwany. Ogólnie ostateczne parametry łączymy w dane parametry za pomocą jednego sposobu, tzn. za pomocą tej funkcji, i dla tak uzyskanej tablicy tworzymy funkcję zwracaną przez funkcję w nagłówku, która przyjmuje parametr, który jest kluczem tej uzyskanej tablicy. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.PobierzElementNumerowanyZFrameLubTablicy(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Weźmy najprostszy sposób realizacji tej funkcji, w realizacji: {{Code|1-1, 2-2, 3-3}}, czyli ten opis jest zaraz poniżej. Weźmy funkcję, którą można wywoływać z wieloma parametrami, jak i w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, którą przykładowo piszemy jego wywołanie wewnątrz innej funkcji na pięć sposobów, czyli teraz pierwszy sposób z tylko z parametrem, więc tablicą ramki tablicy transportu wywodzącą się z ramki uruchomioną w wikikodzie w jakimś szablonie rodzicu: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"](frame); </syntaxhighlight> a teraz drugi sposób, pisząc, bezpośrednio inaczej formułując wywołanie tej funkcji, używając zmiennych tablicowych tablicy ramki, ale to nie jest tak naprawdę tablica ramka tablicy transportu, tylko parametr podany bezpośrednio do funkcji, tak jak się to robi w języku {{lpg|Lua}}, nie jak w przykładzie powyżej, więc: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{args={"wartość1","wartość2","wartość3",},}; </syntaxhighlight> Lub równoważnie, pisząc, nie używając zmiennej {{Code|args}}: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]{"wartość1","wartość2","wartość3",}; </syntaxhighlight> Albo te parametry wsadzając do funkcji: <syntaxhighlight lang="lua"> local wynik=p["Nazwa funkcji"]("wartość1","wartość2","wartość3"); </syntaxhighlight> Można też wywołać to wszystko w ramce, {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikpdzie, wtedy wsadzając parametry do ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|wartość1|wartość2|wartość3}} </syntaxhighlight> A jak połączyć wszystkie te pięć sposobów, posługiwać się tymi sposobami wewnątrz funkcji {{Code|Nazwa funkcji}} w sposób jednolity, jedynie wtedy należy skorzystać z funkcji z definiowaną w jakimś module w sposób: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); ... end; </syntaxhighlight> Wtedy za pomocą zmiennej {{Code|PobierzElementNumerowanyZFrameLubTablicy}} dostaliśmy się do funkcji, która przyjmmuje jedyny parametr, aby dostać się do elementów tablicy uzyskanej w wewnątrz tej funkcji, zdefiniowaną w tablicy {{Code|tablica_prametrow_funkcji}}, która jest nic innym jak zestawem parametrów w funkcji: {{Code|Nazwa funkcji}}. W pierwszym i drugim sposobem zmienna ta nazwijmy to jako {{Code|args}} jest zmienną z podtablicy innego {{Code|args}} przekazanych jako parametr tablicy do funkcji, w trzecim sposobie tą zmienną jest cała tablica, a czwartym jest zestaw parametrów. A czym się różnią się te sposoby, a więc te sposoby można powiązać jedną tylko funkcją powiedzianą w nagłówku według przykładu podaną zaraz powyżej, wtedy możemy dostawać się do tych samych zmiennych o takich samych nazwach i wartościach, ale w różnych reprezentacjach na różne sposoby, wtedy można powiedzieć, że: <syntaxhighlight lang="lua"> args[1]="wartość1"; args[2]="wartość2"; args[3]="wartość3"; </syntaxhighlight> Czyli w wyniku działania funkcji w nagłówku, otrzymamy funkcję zwracającą te wartości, która operuje na tej tablicy, której wynikiem jest zestaw zmiennych ponumerowanych, ogólnie nienazwanych, której wartości odpowiadają te podane w ramce ostatniej powyżej. Na podstawie tego wiemy, jak działa funkcja ta z nagłówka. Pisząc w inny sposób, można też wskazywać: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(...) local tablica_prametrow_funkcji={...}; local parametry_modul=require("Module:Parametry"); local PobierzElementNumerowanyZFrameLubTablicy=parametry_modul.PobierzElementNumerowanyZFrameLubTablicy(tablica_prametrow_funkcji); local wartosc1=PobierzElementNumerowanyZFrameLubTablicy("nazwa1") or PobierzElementNumerowanyZFrameLubTablicy(1); local wartosc2=PobierzElementNumerowanyZFrameLubTablicy("nazwa2") or PobierzElementNumerowanyZFrameLubTablicy(2); local wartosc3=PobierzElementNumerowanyZFrameLubTablicy("nazwa3") or PobierzElementNumerowanyZFrameLubTablicy(3); end; </syntaxhighlight> Zmienne w przykładzie o kluczach: {{Code|nazwa1}}, {{Code|nazwa2}} i {{Code|nazwa3}}, posiadające pewne swoje wartości, to są zmienne w tablicy {{Code|tablica_prametrow_funkcji}}, podane też jako zmienne, jako pewne argumenty tablicy, który są w tej funkcji zwracanej jako argument (parametr) funkcji, jeżeli argumenty podano w postaci jednego parametru funkcji w postaci pewnej tablicy z np. elementami nazwanymi, lub jako wiele argumentów w ramce, w wikikodzie, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w pewnym szablonie, a rozpatrując dalej elementy względem ich nazw, np. alternatywnych, to te numery mogą być: {{Code|1}}, {{Code|2}} i {{Code|3}}, to jest numer parametru, jeżeli argumenty do funkcji podano w postaci wielu jego parametrów. === {{Code|p.PobierzParametr(frame,...)}} === Ta funkcja zwraca znów inną funkcję, która ma jedyny parametr, mówiący jakiego parametru poszukujemy, co jest wyjaśnione w definicji funkcji z nagłówka, że ona zwraca tą właśnie funkcje. Definicja skrótowa dunkcji: <syntaxhighlight lang="lua"> function p.PobierzParametr(frame,czy_frame_lub_parent,czy_frame) ... return function(nazwa) return __pobierz_parametr_table_args(nazwa); end; end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}} - parametry logiczne dodatkowe funkcji. Funkcja zwraca jednocześnie dwie wartości, ta zwrócona z funkcji z nagłówka, prawdziwą wartość, i numer metody w postaci: {{Code|return wartosc, numer_metody}}. Ta funkcja zwracana ma w swojej definicji inną jeszcze funkcję z tym samym parametrem, co jego rodzic, i to jest za każdym razem inna funkcja w zależności z jakim typem danych się posługujemy {{Code|frame}} i jakie podaliśmy parametry, tzn. pod warunkiem, gdy zmienna {{Code|frame}} jest tablicą, czyli te zmienne druga: {{Code|czy_frame_lub_parent}} (jeżeli funkcja jest uruchomiona w ramce w szablonie, jeżeli wartość {{Code|true}}, to ona wybiera raz parametr z: {{Code|frame.args[nazwa or 1]}}, a za innym razem z {{Code|pf.args[nazwa or 1]}}, gdzie {{Code|pf{{=}}frame:getParent()}}, tutaj jest zwracana wartość: {{Code|return wartosc,2}}), czy trzecia: {{Code|czy_frame}} (która mówi, jeżeli funkcję uruchomiono w ramce, ale przy wartości fałszywej tego pierwszego podanego parametru, mówi, że przy wartości {{Code|true}} tego parametru, wybierana jest zawsze wartość {{Code|frame.args[nazwa or 1}}}, w przeciwnym wypadku uruchamiana jest funkcja {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, tutaj zwracana jest wartość {{Code|return wartosc,1}}). Jeżeli wartością {{Code|frame}} jest wartość nietablicowa, ale niebędącą wartością {{Code|nil}}, wtedy ustawiana jest funkcja, która tylko za pierwszym razem zwraca nienilową wartość {{Code|return wartosc,0}}, a później zwraca wartość {{Code|return nil,0}}. Gdy wartością {{Code|frame}} jest {{Code|nil}}, to funkcja zawsze wraca tą wartość {{Code|return nil,0}}. Powyższy sposób działa również dobrze, gdy zdefiniujemy w parametrach funkcji fałszywą funkcję {{Code|frame.getParent}}. Gdy funkcja nie jest uruchamiana w ramce lub funkcja {{Code|frame.getParent}} nie jest zdefiniowana, to wtedy funkcja wchodzi zawsze w ten jej krok, jakby {{Code|czy_frame_lub_parent}} było {{Code|false}} według tego powyżej, to wtedy brana jest zmienna {{Code|czy_frame}}, i jaką wartość ona przyjmuje. Funkcję pisze się według sposobu, którą się wywołuje według: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); local wartosc1=PobierzParametr("nazwa1") or PobierzParametr(1); local wartosc2=PobierzParametr("nazwa2") or PobierzParametr(2); local wartosc3=PobierzParametr("nazwa3") or PobierzParametr(3); </syntaxhighlight> Na wypadek wartości nietabelowej, tą wartość zapisuje się jako pierwszą w kodzie {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, a dla wartości tabelowych, jaka jest kolejność to jest obojętne, byle by to było sensowne. Tę funkcję podobnie się wywołuje jak funkcję: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}. Wartością {{Code|frame}} nie musi być tablica ramki tablicy transportu, równie dobrze może być to dowolna tablica lub wartość nietablicowa. Weźmy ramkę, w której uruchamiamy funkcję ramki: <syntaxhighlight lang="mediawiki"> {{#invoke:Nazwa modułu|Nazwa funkcji|nazwa1=wartość1|nazwa2=wartość2|wartość3|wartość4|wartość5|wyspecjalizowana=tak}} </syntaxhighlight> Ona musi być wywołana z parametrem {{Parametr|wyspecjalizowana|tak}}, jako podpowiedź, że liczą sie parametry ramki dziecka, a nie jego rodzica, czyli szablonu. Wtedy funkcję {{Code|Nazwa funkcji}} definiujemy: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,true); ... end; </syntaxhighlight> Wtedy parametr {{Parametr|wyspecjalizowana|tak}} jest ignorowany, a przy wartości {{Code|false}} drugiego parametru funkcji, czyli wywołania: {{Code|local PobierzParametr{{=}}parametry_modul.PobierzParametr(frame,false);}}, już nie, ale nie zawsze. W takim przypadku raz jest brana wartość, jeżeli istnieje, z {{Code|frame.args}}, a jak nie to z: {{Code|pf.args}}. Weźmy inny przypadek: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,true); ... end; </syntaxhighlight> Przy tym też parametr: {{Parametr|wyspecjalizowana|tak}}, jest ignorowany, wtedy jest zawsze wybierana do rozważań tablica: {{Code|frame.args}}. Znów w innym przypadku, gdzie parametr: {{Parametr|wyspecjalizowana|tak}}, jest zawsze rozważany w naszym wypadku: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame,false,false); ... end; </syntaxhighlight> To to wywołanie, wtedy dokładnie działa jak funkcja: {{Code|{{sr|#p.PobierzArgsParametry(frame,...)|p=Parametry}}}}, a zwrócona funkcja: {{Code|PobierzParametr}} pobiera elementy z tak uzyskanej tablicy {{Code|args}}. W przypadku, gdy {{Code|frame}} nie jest tablicą, wtedy parametry: {{Code|czy_frame_lub_parent}} i {{Code|czy_frame}}, są w takim przypadku zawsze ignorowane, ale muszą być ustawione na wypadek, gdy by do funkcji {{Code|Nazwa funkcji}} wsadzono tablicę, np.z ramki tablicę ramki tablicy transportu. Najprostszym często ogólnym przykładem, który prawie zawsze jest stosowany: <syntaxhighlight lang="lua"> local p={}; p["Nazwa funkcji"]=function(frame) local parametry_modul=require("Module:Parametry"); local PobierzParametr=parametry_modul.PobierzParametr(frame); ... end; </syntaxhighlight> Wtedy parametr: {{Parametr|wyspecjalizowana|tak}}, jest prawie zawsze nieignorowany, ale nie zawsze. == Funkcje wartości logicznej == Funkcje te wykorzystują funkcję: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}, jeżeli mamy ciąg składający się z samych znaków odstępu, to funkcja zwraca wartość odpowiadający wartości: {{Code|false}}, a dla innych wartości to działa jak: {{Code|true}}, dla instrukcji warunkowej: {{Code|{{s|#if:coś|wtedy|przeciwnie}}}}. === {{Code|p.And(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|and}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli wszystkie z tych wartości są równe wartości {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.And(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1|wartość2|wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|And|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Or(frame)}} === Funkcja działa operator logiczny operatorowy: {{Code|or}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartości parametrów składającą się, przynajmniej, któreś z nich, z nie znaków odstępu i niebędące ciągami pustymi, na wartość składający się z ciągowi niepustemu, czyli {{Code|tak}}, w w przeciwnym wypadku mamy wartość wyniku równą ciągowi pustemu. Funkcja zamienia wartości każdego parametru na wartości logiczne: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i jeżeli z któreś z tych wartości jest {{Code|true}}, to funkcja zwraca {{Code|tak}}, w przeciwnym wypadku zwraca wartość równą ciągowi pustemu. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Or(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|wartość1||wartość3}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|tak}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Or|||}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|nie}}. === {{Code|p.Not(frame)}} === Funkcja działa jak operator logiczny operatorowy: {{Code|not}}, w języku {{lpg|Lua}}. Funkcja służy jedynie do uruchamiania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, zamienia wartość składającą się z nie znaków odstępu i niebędący ciągiem pustym, na wartość składający się z ciągu pustego, i odwrotnie, czyli wartość pustą na wartość mający w sobie inne znaki niż odstępu. Funkcja zamienia wartość pierwszego parametru na wartość logiczną: {{Code|true}}/{{Code|false}} (według funkcji: {{Code|{{sr|#p["CzyTakCiąg"](...)|p=Parametry}}}}), i zamienia ją na przeciwność, wartości {{Code|true}} odpowiada {{Code|tak}}, a {{Code|false}} odpowiada wartości pustej. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Not(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Przykład działania funkcji w ramce {{Lpg|Lua}} w {{lpr|Lua|Scribunto}}, w wikikodzie w szablonie, bo ta funkcja służy do uruchamiania właśnie w szablonach, jest: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|tak}}|tak|nie}} </syntaxhighlight> W powyższym przykładzie funkcja zwróci wartość {{Code|nie}}. A w przykładzie z przeciwną zwracaną wartością: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Not|}}|tak|nie}} </syntaxhighlight> natomiast zostanie zwrócona wartość {{Code|tak}}. == Funkcje porównań == === {{Code|p.Mniejszy(frame)}} === Funkcja zastępuje parser logiczny: {{Code|{{s|#expr:coś|wtedy|przeciwnie}}}}, dla porównania dwóch wartości logicznych, działa on szybciej niż ten parser, bo on musi uwzględniać skomplikowaność wyrażeń matematycznych do policzenia, a nasza funkcja w języku: {{lpg|lua}} w {{lpr|Lua|Scribunto}}, już nie. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Mniejszy(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Funkcja sprawdza, czy spełniona jest wartość mniejszości pierwszego parametru liczbowego: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5|3}}|tak|nie}} </syntaxhighlight> Funkcja wtedy zrzuci wartość {{Code|nie}}, bo {{Code|5}} jest większe niż {{Code|3}}. Można też sprawdzić, czy liczba jest ujemna, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|-5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|tak}}. Można też sprawdzić, czy liczba jest dodatnia, za pomocą wywołania: <syntaxhighlight lang="mediawiki"> {{#if:{{#invoke:Parametry|Mniejszy|5}}|tak|nie}} </syntaxhighlight> Funkcja zrzuci wartość {{Code|nie}}. == Ile jest podanych elementów w szablonie według parametrów ramki == === {{Code|p.IlePodano(frame)}} === Funkcja sprawdza, ile jest podanych parametrów w parametrach rodzica szablonu z parametrów nazwanych lub nienazwanych, ale traktowanych jak nazwane, podanych w dziecku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IlePodano(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. Wywołanie szablonu, w której jest wywołana funkcja: {{Code|{{m|Parametry|IlePodano}}}}, jako z parametrami, i nie tylko, podanymi w ramce tej funkcji w tym szablonie: <syntaxhighlight lang="mediawiki"> {{Nazwa szablonu|nazwa1=wartość1|nazwa2=wartość2|nazwa3=wartość3|wartość4|wartość5}} </syntaxhighlight> To wtedy wywołanie w nim naszej funkcji bibliotecznej w postaci ramki wygląda, jako: <syntaxhighlight lang="mediawiki"> {{#invoke:Parametry|IlePodano|nazwa1|nazwa3|2|nazwa4|5}} </syntaxhighlight> Funkcja zwróci wartość {{Code|3}}, a nie {{Code|5}}, bo trzy tylko parametry znaleziono w ramce wywołania szablonu, a parametr: {{Code|nazwa4}} i {{Code|5}}, tam wcale nie występują. == Metafunkcje i metatabele == Rozdział przedstawia metatabele i w niej zdefiniowane metafunkcje. === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter}} === Jest to zdefiniowana metatabelka, którego definicja i przyporządkowanie innej normalnej tablicy, wygląda: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter=parametry_modul.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter; local tablica_normalna={["nazwa1"]="wartosc1",["nazwa2"]="wartość2",["nazwa3"]="wartość3",}; setmetatable(tablica_normalna,metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter); </syntaxhighlight> === {{Code|p.metatablica_dla_elementowych_miar_tablicy_wedle_niewielkich_liter.__index(t,klucz)}} === Jeżeli przyporządkujemy wartości {{Code|tablica_normalna}} metatabelkę z metafunkcjami, w tym przypadku metafunkcji {{Code|.__index(t,klucz)}}, wtedy możemy pisać wywołanie: <syntaxhighlight lang="lua"> local wartosc1=tablica_normalna["NAZWA1"]; </syntaxhighlight> Uzyskaną wartością jest: {{Code|wartość1}}, bo wartość: {{Code|NAZWA1}} jest zamieniana na małe litery w tym wywołaniu, ale powyżej podano wartość {{Code|nazwa1}} w tablicy {{Code|tablica_normalna}}, wtedy obie wartości są sobie równe, a więc uzyskamy taki wynik. == Iteratory == Poniższe operatory możemy wykorzystać w funkcjach: analogicznego do {{Code|ipairs}}, dla iteratora: {{Code|{{sr|#p.IteratorPoNumerowanychElementachTablicy(t)|p=Parametry}}}}, wynikłej z jego funkcji z wartości zwracanej, i analogicznego do {{Code|next}} (iteratora po kluczach) w {{Code|pairs}}, dla iteratora: {{Code|{{sr|#p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)|p=Parametry}}}}, wynikłe z jego funkcji z wartości zwracanej. === {{Code|p.IteratorPoNumerowanychElementachTablicy(t)}} === Iterator służy do iterowania po kolei liczb w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora. Można ją zdefiniować do obsługi innego iterowania po parametrach numerowanych, analogicznie do {{Code|ipairs}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorPoNumerowanychElementachTablicy(t) ... return function() ... end; end; </syntaxhighlight> Parametry funkcji: * {{Code|t}} - tablica, po której iterujemy po elemenetach numerowanych. Przykład działania iteratora jest: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={1,2,3,4,5,6,7,8,9,10,}; local iter=parametry_modul.IteratorPoNumerowanychElementachTablicy(tablica); for name, value in iter do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> === {{Code|p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja)}} === Iterator służy do iterowania po kolei po zsortowanych kluczach po kolei alfabetycznie, którym są przyporządkowane wartości o pewnych tych kluczach w pewnych tablicach, używając do tego celu tablicy, zdefiniowanego iteratora, metatabelki i metafunkcji w niej zdefiniowanej, gdzie: {{Code|funkcja}}, jest funkcją sortującą łańcuchy znakowe. Można ją zdefiniować do obsługi innego iterowania po parametrach nazwanych za pomocą: {{Code|pairs}}, definiując funkcję: {{Code|__next}}, analoga do {{Code|next}}, jako iteratora po kluczach posortowanych, która jest wartością zwracaną przez funkcję w nagłówku. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(tabela,funkcja) ... return function(tablica,klucz) ... end; end; </syntaxhighlight> Parametry funkcji: * {{Code|tabela}} - tabela, po której iterujemy, * {{Code|funkcja}} - funkcja sortująca. Parametry funkcji zwracanej: * {{Code|tablica}} - tabela operowana, * {{Code|klucz}} - klucz, dzięki któremu szukamy następny element. Zdefiniujmy metatablicę z metafunkcją: {{Code|__pairs}}, wtedy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local tabela={["D"]="wartość1",["A"]="wartość2",["F"]="wartość3",["C"]="wartość4",}; local __metatabelka={}; __metatabelka.__pairs=function(t) local funkcja_sortujaca=nil; local __next=parametry_modul.IteratorKluczeTabeliAlfabetycznieSortujDoPrzodu(t,funkcja_sortujaca); return __next,t,nil; end; setmetatable(tabela,__metatabelka); for name,value in pairs(tabela) do mw.log("Klucz:",klucz,"Wartość:",value); end; </syntaxhighlight> == Funkcje wartości minimalnej i maksymalnej == === {{Code|p.Max(frame)}} === Funkcja liczy maksimum dwóch podanych wartości, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Max|5|3}}}} → {{Tt|{{#invoke:Parametry|Max|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Max}} lub {{s|Maksimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Max|5|3}}}} → {{Tt|{{Max|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Max|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Max}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy maksimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich maksimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Max(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Max|5|3}} </syntaxhighlight> Wynikiem tego jest maksimum z tych liczb równą: {{Code|5}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia maksimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local maksimum=parametry_modul.Max(5,3); </syntaxhighlight> Wartością z dwóch liczb jest wartość maksymalna: {{Code|5}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. === {{Code|p.Min(frame)}} === Funkcja liczy minimum dwóch podanych liczb, podaną w jednostkach bezwymiarowych. ==== Odpowiednik szablonowy ==== Dla wersji ramkowej uruchomioną w wikikodzie, np. szablonu: * {{Code|{{m|Parametry|Min|5|3}}}} → {{Tt|{{#invoke:Parametry|Min|5|3}}}} Dla wersji szablonowej, której odpowiednikami szablonowymi są: {{s|Min}} lub {{s|Minimum}}, który można wykorzystać jej definicji wersję ramkową, ale niekoniecznie, a tutaj wykorzystuje parser {{Code|{{s|#expr:coś}}}}. * {{Code|{{s|Min|5|3}}}} → {{Tt|{{Min|5|3}}}} Ta wersja szablonowa wykorzystuje funkcję: {{s|W pikselach}}, do zamiany tej samej liczby w liczbę, ale też liczby w różnych jednostkach bezwzględnych z mianem na końcu na zamianę w liczbę pikseli podaną bez wymiarowo. Wywołanie: {{Code|{{m|Parametry|Min|5|3}}}}, zajmuje mniej zasobów niż: {{Code|{{s|Min}}}}, bo to ostatnie wykorzystuje do liczenia pracochłonną funkcję: {{m|Plik|W pikselach}}, a to pierwsze już nie, liczy minimum bezpośrednio. ==== Funkcja biblioteczna ==== Funkcja do wywołania w ramce dla dwóch parametrów licząca ich minimum. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.Min(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu. W ramce można go wywołać bezpośrednio, dla przykładu dwóch naturalnych parametrów, ale one mogą być też rzeczywiste: <syntaxhighlight lang="lua"> {{#invoke:Parametry|Min|5|3}} </syntaxhighlight> Wynikiem tego jest minimum równą: {{Code|3}}. Tę funkcję można wykorzystać bez pośrednio w programie {{lpg|Lua}} do liczenia minimów dwóch liczb. Ten kod piszemy: <syntaxhighlight lang="lua"> local parametry_modul=require("Module:Parametry"); local minimum=parametry_modul.Min(5,3); </syntaxhighlight> Wartością minimalną z dwóch liczb jest: {{Code|3}}. Widzimy, że w parametrach funkcji nie musimy wykorzystywać żadnej tablicy ramki, bo ona wykorzystuje funkcję: {{Code|{{sr|#p.PobierzElementNumerowanyZFrameLubTablicy(frame)|p=Parametry}}}}, do liczenia parametrów tego obiektu ramki, by uzyskać argumenty podane w parametrach tej funkcji, czy to w wersji wywołaną w ramce, czy jako w zwykłej funkcji. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> g8nsi5gdkz7leiizx40emtddz70upwp 4 63362 541348 540267 2026-04-30T07:34:41Z Persino 2851 541348 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Specjalne}}|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 specjalne_modul=require("Module:Specjalne"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Funkcje w tym module służą do specjalnych celów do obsługi na tekstach, nie tak jak {{Code|{{ld2|Szeregi}}}} (modyfikuje tekst, nawet w liniach), czy {{Code|{{ld2|Strony}}}} (która sprawdza wartość tekstową), a nawet {{Code|{{ld2|Parametry}}}} (do obsługi parametrów), albo {{Code|{{ld2|Html}}}} (do obsługi na tekstach związanych ze stronami HTML). Te funkcje służą do operacji na tekstach związanych z mechanizmem {{Strong|MediaWiki}}. == {{Code|GranicznieSzereg()}} == Jest to funkcja lokalna w module {{Code|{{ld2|Specjalne}}}}, używana tylko wewnątrz funkcji należących do jego tablicy transportu. Funkcja ustawia tak wzór, który służy do wyszukiwania tekstu bezpośrednio do całego tekstu, jeśli {{Code|czy_granicznie{{=}}true}}, a gdy nie, to ta zmienna musi przyjmować wartość {{Code|nil}} lub {{Code|false}}. Definicja skrótowa jest: <syntaxhighlight lang="lua"> local function GranicznieSzereg(wzor,czy_granicznie)...end; </syntaxhighlight> Parametry: * {{Code|wzor}} - produkuje wzor, który nie dopasowuje domyślnie do całego ciągu znakowego, * {{Code|czy_granicznie}} - robi ze wzoru wyrażenie regularne dopasowujące do całego ciągu znakowego. Przykład użycia funkcji: <syntaxhighlight lang="lua"> local wzor="%[%[.-%]%]"; local wzor2=GranicznieSzereg(wzor,true); </syntaxhighlight> Funkcja zwraca wynik {{Code|wzór2{{=}}"^%[%[.-%]%]$"}}. A gdy drugi parametr jest np. równy {{Code|nil}} lub {{Code|false}}, wtedy funkcja nie zmienia podanego wzoru, tylko go powtarza. == {{Code|p.ZnakiSpecjalneAnulowaniaIchZnaczeniaTagowegoMediaWiki()}} == Funkcja zmienia tagi znaczników, tzn. w nich znaki: {{Code|<}} i {{Code|>}}, na odpowiednie szablony, według podanego w module: {{Code|{{ld2|Specjalne/dane}}}}, kodu: <syntaxhighlight lang="lua"> local p={} p.szablony_anulowania_znaczeniowego_tagowego_mediawiki={ ["<"]="{{Mniejszy}}", [">"]="{{Większy}}", }; </syntaxhighlight> Definicja skrótowa jest: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneAnulowaniaIchZnaczeniaTagowegoMediaWiki(szablon)...end; </syntaxhighlight> Parametry: * {{Code|szablon}} - tekst, w którym znaki specjalne {{Code|<nowiki><></nowiki>}} są zamieniane na wywołania szablonowe kolejno: {{s|Mniejszy}} i {{s|Większy}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="<nowiki>Oto jest tekst</nowiki>"; local tekst2=specjalne_modul.ZnakiSpecjalneAnulowaniaIchZnaczeniaTagowegoMediaWiki(tekst); </syntaxhighlight> Wynikiem tego kodu jest tekst ukryty pod zmienną {{Code|tekst2}}: <syntaxhighlight lang="lua"> local tekst2="{{Mniejszy}}nowiki{{Większy}}Oto jest tekst{{Mniejszy}}/nowiki{{Większy}}"; </syntaxhighlight> Ta funkcja wyłącza znaczenie specjalnych tagów mechanizmu {{Strong|MediaWiki}}, i je jako swoje on nie interpretuje, jedynie rozpatruje to jako zwykły tekst. Taki tekst można włączyć do funkcji {{Code|frame:preprocess}}, wtedy jedynie szablony {{s|Mniejszy}} i {{s|Większy}} zostaną rozwinięte, nie naruszając magiczności tych tagów. Tę funkcję jedynie się stosuje wtedy, gdy chcemy, by te tagi nie zostały zamienione na specjalne kody {{Strong|MediaWiki}} tego mechanizmu. Tak robimy, by później dało je usunąć bardzo łatwo, nie naruszając ich zawartości. == {{Code|p["UsuńŚciśleOkreśloneKategorie"](frame)}} == Szablon usuwa ściśle określone kategorie z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńŚciśleOkreśloneKategorie"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|kategoria}} - parametr mówiący jakie kategorie usunąć o takim samym adresie, w przypadku niepodania tego parametru, używane jest domyślne dopasowanie do wszystkich kategorii według wzoru {{Code|<nowiki>([^%[%]|]*)</nowiki>}}, * {{Code|3}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Funkcja dopasowuje kategorie opisane przez nazwę kanoniczną: {{Code|Category}}, lub niekanoniczną: {{Code|Kategoria}}, niezależnie, czy takie wywołanie posiada nazwę sortowania, czy nie. Funkcja usuwa kategorie o danej nazwie, niezależnie jak ona została podana z iloma odstępami, czy dolnymi myślnikami, na jego początku, końcu, a nawet wewnątrz. Funkcja ustawia tak zmienną {{Code|kategoria}}, a właściwie ją przekształca, jeżeli została podana, tzn. zbędne myślniki i odstępy na początku i końcu z niej są usuwane, a wewnątrz je zostają zastąpione w niej przez wyrażenie: {{Code|[%s_]+}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego kategorie: [[Category:Nazwa kategorii|Nazwa sortowania 1]], i następna: [[Kategoria:Nazwa kategorii|Nazwa sortowania 2]]"; local kategoria="Nazwa kategorii"; local granicznie=""; local tekst2=specjalne_modul["UsuńŚciśleOkreśloneKategorie"]{tekst=tekst,kategoria=kategoria,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[[Category:Nazwa kategorii|Nazwa sortowania 1]]</nowiki>}} i {{Code|<nowiki>[[Kategoria:Nazwa kategorii|Nazwa sortowania 2]]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego kategorie: , i następna: "; </syntaxhighlight> == {{Code|p["UsuńKategorie"](frame)}} == Szablon usuwa wszystkie kategorie z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńKategorie"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego kategorie: [[Category:Nazwa kategorii|Nazwa sortowania 1]], i następna: [[Kategoria:Nazwa kategorii|Nazwa sortowania 2]]"; local granicznie=""; local tekst2=specjalne_modul["UsuńKategorie"]{tekst=tekst,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[[Category:Nazwa kategorii|Nazwa sortowania 1]]</nowiki>}} i {{Code|<nowiki>[[Kategoria:Nazwa kategorii|Nazwa sortowania 2]]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego kategorie: , i następna: "; </syntaxhighlight> == {{Code|p["UsuńZnaczniki"](frame,...)}} == Szablon usuwa wszystkie znaczniki bez zawartości z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńZnaczniki"]=function(frame,jakie,funkcja1,funkcja2)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Parametry typowe dla funkcji: * {{Code|jakie}} - nazwa znacznika, jaka ma być użyta do usuwania z tekstu {{Code|tekst}} znaczników bez zawartości z tym tagiem, w przeciwnym wypadku są usuwane wszystkie znaczniki bez zawartości, * {{Code|funkcja1}} - funkcja wywołana przed usuwaniem znaczników bez zawartości, * {{Code|funkcja2}} - funkcja wywołana po usuwaniu znaczników bez zawartości. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego w niej znaczniki: <span id=\"toc_1\" klasa=\"nazwa_klasy_1\">zawartość pierwsza</span>, i następna: <span id=\"toc _2\" klasa=\"nazwa_klasy_2\">zawartość druga</span>."; local tekst2=specjalne_modul["UsuńZnaczniki"](tekst,"span"); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja jedynie wtedy może być użyta z parametrami ramki. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli znaczniki: {{Code|<nowiki><span id="toc_1" klasa="nazwa_klasy_1"></nowiki>}} i {{Code|<nowiki><span id="toc _2" klasa="nazwa_klasy_2"></nowiki>}} oraz ich znaczniki końcowe, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego w niej znaczniki: zawartość pierwsza, i następna: zawartość druga."; </syntaxhighlight> == {{Code|p["UsuńKomentarze"](frame)}} == Szablon usuwa wszystkie komentarze oznaczone blokiem początkowym {{Code|<nowiki><!--</nowiki>}} i końcowym {{Code|<nowiki>--></nowiki>}}, czyli razem (oznaczając to wyrażeniem regularnym {{lpg|Lua}} w {{lpr|Lua|Scribunto}}): {{Code|<nowiki><!%-%-.-%-%-></nowiki>}}, z tekstu wikikodu, dopasowując do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńKomentarze"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego kategorie w komentarzach: <!--[[Category:Nazwa kategorii|Nazwa sortowania 1]], i następna: [[Kategoria:Nazwa kategorii|Nazwa sortowania 2]]-->"; -- Analogicznie: local tekst2=specjalne_modul["UsuńKomentarze"]{tekst=tekst,}; -- Analogicznie: local tekst2=specjalne_modul["UsuńKomentarze"]{args={tekst=tekst,},}; local tekst2=specjalne_modul["UsuńKomentarze"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja usuwa komentarze z tekstu oznaczonej zmienną {{Code|tekst}}, tworząc nowy tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego kategorie w komentarzach: "; </syntaxhighlight> == {{Code|p["UsuńSzablonyStylów"](frame)}} == Szablon usuwa wszystkie szablony stylów z tekstu wikikodu, dopasowując do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńSzablonyStylów"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego w niej szablony stylów: '\"`UNIQ--templatestyles-00000048-QINU`\"'"; -- Analogicznie: local tekst2=specjalne_modul["UsuńSzablonyStylów"]{tekst=tekst,}; -- Analogicznie: local tekst2=specjalne_modul["UsuńSzablonyStylów"]{args={tekst=tekst,},}; local tekst2=specjalne_modul["UsuńSzablonyStylów"](tekst); </syntaxhighlight> W funkcji do usuwania stylów używana jest funkcja w postaci wywołania: <syntaxhighlight lang="lua"> local szablonowe_modul=require("Module:Szablonowe"); local wzor_stylowy=szablonowe_modul.NormaWzoruKodowaniaTekstu("templatestyles","%w+"); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli szablon stylów w postaci: {{Code|<nowiki>'"`UNIQ--templatestyles-00000048-QINU`"'</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego w niej szablony stylów: "; </syntaxhighlight> == {{Code|p["UsuńWywołaniaPlików"](frame)}} == Szablon usuwa wszystkie wywołania plikowe, oznaczone, np.: {{Code|Image}}, {{Code|Grafika}}, {{Code|File}} i {{Code|Plik}}, z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńWywołaniaPlików"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego wywołania plikowe: [[Plik:Nazwa pliku 1|300x400px|thumb|right|Nazwa opisu dla pliku 1]], i następna: [[File:Nazwa pliku 2|300x400px|thumb|right|Nazwa opisu dla pliku 2]]"; local granicznie=""; local tekst2=specjalne_modul["UsuńWywołaniaPlików"]{tekst=tekst,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[[Plik:Nazwa pliku 1|300x400px|thumb|right|Nazwa opisu dla pliku 1]]</nowiki>}} i {{Code|<nowiki>[[File:Nazwa pliku 2|300x400px|thumb|right|Nazwa opisu dla pliku 2]]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego wywołania plikowe: , i następna: "; </syntaxhighlight> == {{Code|p["UsuńInterwiki"](frame)}} == Szablon usuwa wszystkie interwiki z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńInterwiki"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego interwiki: [[en:w:Nazwa strony 1]], i następna: [[en:w:Nazwa strony 2]]"; local granicznie=""; local tekst2=specjalne_modul["UsuńInterwiki"]{tekst=tekst,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[[en:w:Nazwa strony 1]]</nowiki>}} i {{Code|<nowiki>[[en:w:Nazwa strony 2]]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego interwiki: , i następna: "; </syntaxhighlight> == {{Code|p["UsuńZnakiSpecjalne"](frame)}} == Szablon usuwa wszystkie fragmenty tekstu, oznaczone potrójnym i podwójnym cudzysłowem pojedynczym, z tekstu wikikodu, dopasowując do poszczególnych części tekstu, zastępującje tymi fragmentami, ale bez cudzysłowów, a na samym końcu bezpośrednio usuwamy pozostałości z tymi cudzysłowami. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńZnakiSpecjalne"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest '''''wikikod z cudzysłowami'' i z następnym wikitekstem dalej''', i ''końcowym'''''"; --- Analogicznie: local tekst2=specjalne_modul["UsuńZnakiSpecjalne"]{tekst=tekst,}; --- Analogicznie: local tekst2=specjalne_modul["UsuńZnakiSpecjalne"]{args={tekst=tekst,},}; local tekst2=specjalne_modul["UsuńZnakiSpecjalne"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}} fragmenty tekstuz cudzysłowami i zastępuje je bez cudzysłowów: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod z cudzysłowami i z następnym wikitekstem dalej, i końcowym"; </syntaxhighlight> == {{Code|p["UsuńZbędneBiałeZnaki"](frame)}} == Szablon usuwa wszystkie zbędne białe znaki, na początku i końcu oraz wewnątrz, z tekstu wikikodu, dopasowując do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńZbędneBiałeZnaki"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst=" Oto jest tekst wikikodu. "; -- Analogicznie: local tekst2=specjalne_modul["UsuńZbędneBiałeZnaki"]{tekst=tekst,}; -- Analogicznie: local tekst2=specjalne_modul["UsuńZbędneBiałeZnaki"]{args={tekst=tekst,},}; local tekst2=specjalne_modul["UsuńZbędneBiałeZnaki"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa odstępy początkowe i końcowe oraz powtarzające się w wewnątrz tekstu: <syntaxhighlight lang="lua"> local tekst2="Oto jest tekst wikikodu."; </syntaxhighlight> == {{Code|p["ZamieńLinkiWewnętrzneNaTekst"](frame)}} == Szablon usuwa wszystkie linki wewnętrzne na ich nazwę linku, a jeżeli one tego nie posiadają, to jego adres wewnętrzny, z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ZamieńLinkiWewnętrzneNaTekst"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego linki wewnętrzne: [[:Category:Nazwa kategorii|Nazwa linku 1]], i następna: [[Wikibooks:Nazwa strony projektu]]."; local granicznie=""; local tekst2=specjalne_modul["ZamieńLinkiWewnętrzneNaTekst"]{tekst=tekst,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[[:Category:Nazwa kategorii|Nazwa linku 1]]</nowiki>}} i {{Code|<nowiki>[[Wikibooks:Nazwa strony projektu]]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego linki wewnętrzne: Nazwa linku 1, i następna: Wikibooks:Nazwa strony projektu."; </syntaxhighlight> == {{Code|p["ZamieńLinkiZewnętrzneNaTekst"](frame)}} == Szablon usuwa wszystkie linki zewnętrzne na ich nazwę linku, a jeżeli one tego nie posiadają, to jego adres zewnętrzny, z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ZamieńLinkiZewnętrzneNaTekst"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego linki zewnętrzne: [https://pl.wikibooks.org/wiki/Category:Nazwa kategorii|Nazwa linku 1], i następna: [https://pl.wikibooks.org/wiki/Wikibooks:Nazwa strony projektu]."; local granicznie=""; local tekst2=specjalne_modul["ZamieńLinkiZewnętrzneNaTekst"]{tekst=tekst,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[https://pl.wikibooks.org/wiki/Category:Nazwa kategorii|Nazwa linku 1]</nowiki>}} i {{Code|<nowiki>[https://pl.wikibooks.org/wiki/Wikibooks:Nazwa strony projektu]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego linki zewnętrzne: Nazwa linku 1, i następna: https://pl.wikibooks.org/wiki/Wikibooks:Nazwa strony projektu."; </syntaxhighlight> == {{Code|p["CzyPlik"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, czy jest on dokładnie wywołaniem pliku od początku do końca łańcucha, dopasowując do całości tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyPlik"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="[[Plik:Nazwa pliku.jpg|right|thumb|200x300px|Oto jest opis pliku]]"; -- Równoważne: local czy_tak=specjalne_modul["CzyPlik"]{tekst=tekst,}; -- Równoważne: local czy_tak=specjalne_modul["CzyPlik"]{args={tekst=tekst,},}; local czy_tak=specjalne_modul["CzyPlik"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja jedynie wtedy może być użyta z parametrami ramki. Funkcja w przykładzie z wynik w postaci zmiennej {{Code|czy_tak}} jako ciąg pewien niepusty, a jeżeli to nie jest wywołanie pliku, to uzyskujemy wynik {{Code|nil}}. == {{Code|p["CzyInterwiki"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, czy jest on dokładnie wywołaniem interwiki od początku do końca łańcucha, dopasowując do całości tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyInterwiki"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="[[en:w:Stronana wikipedii]]"; -- Równoważne: local czy_tak=specjalne_modul["CzyInterwiki"]{tekst=tekst,}; -- Równoważne: local czy_tak=specjalne_modul["CzyInterwiki"]{args={tekst=tekst,},}; local czy_tak=specjalne_modul["CzyInterwiki"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja jedynie wtedy może być użyta z parametrami ramki. Funkcja w przykładzie z wynik w postaci zmiennej {{Code|czy_tak}} jako ciąg pewien niepusty, a jeżeli to nie jest wywołanie interwiki, to uzyskujemy wynik {{Code|nil}}. A jeżeli na początku interwiki jest {{Code|pl}}, to wtedy to nie jest jednak interwiki, tylko link wewnętrzny, z samej definicji interwiki. == {{Code|p["CzyAdresLinkuWewnętrznego"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, czy jest on dokładnie adresem linku wewnętrznego od początku do końca łańcucha, dopasowując do całości tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyAdresLinkuWewnętrznego"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|dwukropek}} - czy na początku linku wewnętrznego jest dwukropek, wtedy on na pewno jest linkiem wewnętrznym, a jezeli nie to jest sprawdzane, czy jest tak rzeczywiście, * {{Code|2}}, {{Code|tekst}} lub {{Code|adres}} - tekst, który jest pewnym adresem do sprawdzenia,musi być to adres linku wewnętrznego. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|adres}}, a następnie {{Code|2}}, w przeciwnym wypadku jest sprawdzane ich poszczególnych istnienie pokolei i odpowiednio jest ściągana ich zawartość, w zależności, która zmienna jako pierwsza istnieje. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst=":en:w:Nazwa strony w przestrzeni głównej"; -- Równoważne: local czy_tak=specjalne_modul["CzyAdresLinkuWewnętrznego"](tekst); local czy_tak=specjalne_modul["CzyAdresLinkuWewnętrznego"]{tekst=tekst,dwukropek="",}; </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja jedynie wtedy może być użyta z parametrami ramki. Funkcja w przykładzie z wynik w postaci zmiennej {{Code|czy_tak}} jako ciąg pewien niepusty, a jeżeli to nie jest adresem linku wewnętrznego, to uzyskujemy wynik {{Code|nil}}. == {{Code|p["CzyLinkWewnętrzny"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, czy jest on dokładnie wywołaniem linku wewnętrznego od początku do końca łańcucha, dopasowując do całości tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyLinkWewnętrzny"]=function(szablon)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="[[:en:w:Nazwa strony w przestrzeni głównej|Oto jest nazwa linku]]"; -- Równoważne: local czy_tak=specjalne_modul["CzyLinkWewnętrzny"]{tekst=tekst,}; -- Równoważne: local czy_tak=specjalne_modul["CzyLinkWewnętrzny"]{args={tekst=tekst,},}; local czy_tak=specjalne_modul["CzyLinkWewnętrzny"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja jedynie wtedy może być użyta z parametrami ramki. Funkcja w przykładzie z wynik w postaci zmiennej {{Code|czy_tak}} jako ciąg pewien niepusty, a jeżeli to nie jest wywołanie linku wewnętrznego, to uzyskujemy wynik {{Code|nil}}. == {{Code|p["WydzielZwykłyTekst"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, i wydziela tekst z elementów mechanizmu MediaWiki wikikodu wolnego jego od elementów, w tym linki wewnętrzne, zewnętrzne, i inne. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["WydzielZwykłyTekst"]=function(frame,funkcja1,funkcja2)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|nieklasycznie}} - wartość pusta lub niepodana oznacza, że ma rozwijać {{Code|tekst}} (lub {{Code|1}}), jak leci, bez ładowania potężnych szablonów przez mechanizm {{Code|{{M|Szablonowe}}}}, * {{Code|3}} lub {{Code|preprocess}} - czy wikitekst z {{Code|tekst}} (lub {{Code|1}}) ma rozwijać, jak szablon, * {{Code|4}} lub {{Code|kodowanie}} - czy wikikod ma kodować według jego zawartości, * {{Code|5}} lub {{Code|nagłówek}} - niepuste, gdy ma nie usuwać znaczników {{Strong|TemplateStyles}}, znaków specjalnych, czyli pojedynczych cudzysłowów, a także znaczników, stosowana niezależnie od wartości {{Code|nieklasycznie}}, * {{Code|6}} lub {{Code|tablica kodowania}} - gdy {{Code|nieklasycznie}} jest niepuste, i {{Code|kodowanie}} ma zawartość pustą, to ta zmienna posiada tablicę kodów {{Code|{{m|Szablonowe}}}}, która posłuży do rozwijania zakodowanego tą metodą tekstu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Parametry funkcji, nie ramki, czyli: * {{Code|funkcja1}} - funkcja zbierająca zawartości kodów i je przekształca w co innego, zwracany szablon, tj. wikikod nowego szablonu z kodami do rozwinięcia przez {{Code|{{m|Szablonowe}}}}, * {{Code|funkcja2}} - kiedy ma rozwinąć ten kod, a może potraktować go jako wartość już rozwiniętą do końca i zwrócić w funkcji rozwijających kody. Gdy {{Code|nieklasycznie}} jest pusta lub niepodana, to funkcja robi operacje zdefiniowane jako przez funkcje: <syntaxhighlight lang="lua"> local function DwaNawiasyLinkowe(tekst) tekst=p["UsuńKategorie"]{tekst,nieklasycznie,}; tekst=p["UsuńWywołaniaPlików"]{tekst,nieklasycznie,}; tekst=p["UsuńInterwiki"]{tekst,nieklasycznie,}; tekst=p["ZamieńLinkiWewnętrzneNaTekst"]{tekst,nieklasycznie,}; return tekst; end; local function JedenNawiasLinkowe(tekst) tekst=p["ZamieńLinkiZewnętrzneNaTekst"]{tekst,nieklasycznie,}; return tekst; end; local function Komentarze(tekst) tekst=p["UsuńKomentarze"](tekst); return tekst; end; local function SzablonyStylowe(tekst) tekst=p["UsuńSzablonyStylów"](tekst); return tekst; end; local function ZnakiSpecjalne(tekst) tekst=p["UsuńZnakiSpecjalne"](tekst); return tekst; end; local function Znaczniki(tekst,jakie,__FUNKCJA1,__FUNKCJA2) tekst=p["UsuńZnaczniki"](tekst,jakie,__FUNKCJA1,__FUNKCJA2); return tekst; end; local function PreProcessFrame(tekst) local frame=mw.getCurrentFrame(); frame=frame.getParent and frame:getParent() or frame; tekst=frame:preprocess(tekst); return tekst; end; </syntaxhighlight> oprócz operacji: {{Code|SzablonyStylowe(tekst)}}, {{Code|ZnakiSpecjalne(tekst)}} i {{Code|Znaczniki(tekst,jakie,__FUNKCJA1,__FUNKCJA2)}}, gdy {{Code|nagłówek}} jest pusty lub niepodany, wtedy zwracany jest tekst, i kolejno te funkcje, a w przypadku przeciwnej wartości tej zmiennej jest zwracany tylko tekst. Perzy okazji można przez niepustej zmiennej {{Code|preproces}} znaki specjalne znaczników są zamieniane na szablony: {{s|Mniejszy}} i {{s|Większy}}, przy pomocy funkcji: {{Code|tekst{{=}}p.ZnakiSpecjalneAnulowaniaIchZnaczeniaTagowegoMediaWiki(tekst)}}, a następnie rozwijany jest funkcją {{Code|PreProcessFrame(tekst)}} przy wyłączeniu znaczenia znaczniki mechanizmu MediaWiki, nie HTML (bo są to dwie różne sprawy), ta operacja kjest robiona przed operacją przekształcania zmiennej wikikodu. Gdy {{Code|nieklasycznie}} przyjmuje wartość niepustą, wtedy moznaa zakodować tekst wikikodu, przy użyciu niepustej wartości {{Code|kodowanie}}, a przy innej wikikod powinien już być zakodowany na samym wyjściu. Gdy mamy obiekty w rozwijaniu przy pomocy {{Code|{{m|Szablonowe}}}}, można wygenerować nową zawartość szablonu, sprawdzić, czy ona się zgadza instrukcją: <syntaxhighlight lang="lua"> if(((not funkcja1) or (szablon))and((not funkcja2) or funkcja2(szablon,obiekt,kod)))then </syntaxhighlight> i dalej go przekształcać, przy zmiennej {{Code|nagłówek}} nie pustej, pozostawiając kody atrybutów, znaczników, i obiektów określonych normą: <syntaxhighlight lang="lua"> if((obiekt=="NOWIKI")or(obiekt=="MATH")or(obiekt=="ŹRÓDŁO")or(obiekt=="GALERIA")or(obiekt=="MAPAOBRAZU")or(obiekt=="PUDEŁKOWEJŚCIA")or(obiekt=="QUIZ"))then </syntaxhighlight> Po uzyskaniu tak rozwiniętego kody, przy zmiennej {{Code|nagłówek}} niepustej, wtedy zostaje nie zostaną wywołane funkcje: {{Code|tekst{{=}}SzablonyStylowe(tekst)}} i {{Code|tekst{{=}}ZnakiSpecjalne(tekst)}}, ale one zostają zwrócone po kolei wraz z wikikodem w pierwszej kolejności i dalej kolejno te funkcje. A gdy jednak ta pierwsza zmienna w tej linijce zostanie pusta lub niepodana, wtedy zwracany jest sam czysty rozwinięty i oczyszczony tekst. W module {{Code|{{ld2|StronicowyParser/GłównaFunkcjaZbieraniaDanychStron}}}}, wywoływana jest funkcja: <syntaxhighlight lang="lua"> local naglowek,Znaczniki,SzablonyStylowe,ZnakiSpecjalne=specjalne_modul["WydzielZwykłyTekst"]( { -- Wikitekst z elementami mechanizmu MediaWiki tekst=naglowek, -- Zwróć test i funkcje, które muszą coś zrobić; ["nagłówek"]=true, -- Rób operacje według drugiego sposobu rozwijania z dwóch dostępnych; nieklasycznie=true, -- Ma nie kodować wikitekstu kodowanie=false, -- Gotowa tablica kodowania wikitekstu tekst; ["tablica kodowania"]=tablica_analizy_obiektow_strony_dany_modul, }, -- Funkcja: funkcja1; function(szablon,obiekt,kod) local szablon,wynik=SzablonyWywolywane(szablon,obiekt,kod); return szablon,wynik; end, --- Funkcja: funkcja2; function(szablon,obiekt,kod) return czy_indeksowanie; end); </syntaxhighlight> która oczyszcza tekst potrzebnymi funkcjami, zwracając również funkcje,które muszą dokonać dalszej roboty, jeżeli będzie ona potrzebna w jakieś formie. == {{Code|p["WydzielLiczbę"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, i wydziela tekst z elementów mechanizmu wikikodu, w tym linki wewnętrzne, zewnętrzne, i inne. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["WydzielLiczbę"] = function(frame)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Funkcja do swojego działania wykorzystuje funkcję {{Code|{{sr|#p["WydzielZwykłyTekst"](frame)|p=Specjalne}}}}, i wydziela z niej liczbę i ją zwraca w postaci przekłształconej do liczby przy pomocy funkcji {{Code|tunumber}}, a jeżeli takiej liczby nie znalazł, to zwraca {{Code|nil}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="[[:en:w:Wikipedia:Strona projektu wikipdii|Link +547 567 567]]"; -- Równoważnie: local liczba=specjalne_modul["WydzielLiczbę"]{tekst=tekst,}; -- Równoważnie: local liczba=specjalne_modul["WydzielLiczbę"]{args={tekst=tekst,},}; local liczba=specjalne_modul["WydzielLiczbę"](tekst); </syntaxhighlight> Funkcja zwraca liczbę po usunięciu odstępów w postaci zmiennej typu {{Code|number}}: <syntaxhighlight lang="lua"> local liczba=547567567; </syntaxhighlight> Fukcja jest wykorzystywana w funkcji: {{Code|{{sr|#p["Forma wyrażenia po liczbie"](frame)|p=Techniczne}}}}, a więc i jednocześnie w szablonie: {{s|Forma wyrażenia po liczbie}} i jego pokrewnych z niej wynikających. == {{Code|p["PrzetwórzNagłówek"](...)}} == Szablon sprawdza zawartość tekstu wikikodu, i wydziela z niego adres linku wewnętrznego i nazwę linku (nagłówka). Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["PrzetwórzNagłówek"]=function(adres,czy_naglowek_linku,czy_nie_rozwin_adres)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - czy ma liczyć tylko adres (wartość typu {{Strong|string}}) * {{Code|czy_naglowek_linku}} - czy ma liczyc nagłówek linku (wartość typu {{Strong|boolean}}), * {{Code|czy_nie_rozwin_adres}} - czy adres linku ma rozwijać funkcją {{Code|frame:preprocess}} (wartość typu {{Strong|boolean}}). Funkcja używa do swojego działania {{Code|{{sr|#p["WydzielZwykłyTekst"](frame)|p=Specjalne}}}} do wydzielania tekstu, zwraca tutaj przetworzony tekst wydzielony z elementów mechanizmu {{Strong|MediaWiki}}, oprócz zastosowania funkcji: {{Code|Znaczniki}}, {{Code|SzablonyStylowe}} i {{Code|ZnakiSpecjalne}}, które zostaną zastosowane do zwracanej pierwszej wartości podczas liczenia adresu, a podczas liczenia nagłówka tylko funkcja {{Code|Znaczniki}} zostanie zastosowana, ale tylko dla niektórych elementów, a nie dla wszystkich, a za to dla pierwszej, wręcz przeciwnie, dla wszystkich. Przykład: <syntaxhighlight lang="lua"> local adres,naglowek=specjalne_modul["PrzetwórzNagłówek"](adres,true,false); </syntaxhighlight> Funkcja liczy adres linku i nazwę linku (naglowka) linku, które są zwracane kolejno w postaci dwóch zwracanych zmiennych, mając jedynie nieprzetworzony adres w wikikodzie, z prawdopodobnie z elementami mechanizmu MediaWiki, co po zwróceniu dwóch zmiennych otrzymujemy oczyszczony z elementów mechanizmu {{Strong|MediaWiki}} i {{Strong|HTML}}, tak jest w przypadku zmiennej {{Code|adres}}, a dla {{Code|naglowek}} jedynie zawiera niektóre elementy znaczników {{Strong|HTML}}, elementy takie jak: {{Tag|ol}}, {{Code|ul}} i {{Code|li}}, w tej funkcji są usuwane z nagłówka elementu nazwy linku, a inne znaczniki, te które są również znacznikkami {{Strong|HTML}} w mechanizmie nie są usuwane, w tym również znacznik {{Tag|pre}}, który jest jednocześnie znacznikiem {{Strong|HTML}} i znacznikiem mechanizmu {{Strong|MediaWiki}}. == {{Code|p["OdstępyZmiennychNumerowanychSzablonu"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, i wydziela domyślnie prawe odstępy od czarnych znaków wikikodu, w przeciwnym wypadku po podaniu pewnej zmiennej niepustej lewą. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["OdstępyZmiennychNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} - zawartość tekstu z wikikodem * {{Code|lewy}} - czy ma wydzielać lewe odstępy w tekście {{Code|1}}, jeśli niepsuta, w przeciwnym wypadku prawą. Zwykłe szablony mają takę funkcję, że trimują zawartość zmiennej nienazwanej {{Code|1}}, jeżeli ją wsadzono do szablonu do zmiennej nazwanej, a więc wtedy jest konieczne używanie tejże funkcji w wikikodzie w szablonie, aby napisać jego lewe i prawe odstępy. To uwzględnia poniższy przykład: {{ŹródłoKodu|język=mediawiki|{{LuaSubst|{{ns:Template}}:L|inkludowana=tak}}}} Jest to kod przykładowego szablonu przekopiowany z: {{s|l}}, gdzie użycie tejże funkcji jest jednak konieczne. Funkcja kolejno w wywołaniach wydziela lewe a potem prawe odstępy zmiennej {{Code|1}}, przy użyciu parametru {{Parametr|wyspecjalizowana|tak}}. Funkcja produkuje link wewnętrzny za pomocą szablonu {{s|Link wewnętrzny}}, która ucina odstępy na początku i końcu zmiennej {{Code|s}}, a niekoniecznie {{Code|1}}. Przed i po linku są ustawiane odstępy, aby zachować historie produkowanych szablonów, jeżeli przeprowadzamy wizualizację danego szablonu. Szablonem do oglądania jego jest: {{s|PreWikikod}}, w którym jest ukryta funkcja {{Code|{{m|Techniczne|Wikikod}}}}. W tym szablonie jest ukryty inny szablon, a mianowicie {{s|Pre}}, dlatego jest zachowana historia, co do odstępów, i nowych linii, wikikodu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> hjlnxxzp2ayf2b6epkcm9vfb4iudrdn 541349 541348 2026-04-30T07:39:03Z Persino 2851 541349 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Specjalne}}|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 specjalne_modul=require("Module:Specjalne"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Funkcje w tym module służą do specjalnych celów do obsługi na tekstach, nie tak jak {{Code|{{ld2|Szeregi}}}} (modyfikuje tekst, nawet w liniach), czy {{Code|{{ld2|Strony}}}} (która sprawdza wartość tekstową), a nawet {{Code|{{ld2|Parametry}}}} (do obsługi parametrów), albo {{Code|{{ld2|Html}}}} (do obsługi na tekstach związanych ze stronami HTML). Te funkcje służą do operacji na tekstach związanych z mechanizmem {{Strong|MediaWiki}}. == {{Code|GranicznieSzereg()}} == Jest to funkcja lokalna w module {{Code|{{ld2|Specjalne}}}}, używana tylko wewnątrz funkcji należących do jego tablicy transportu. Funkcja ustawia tak wzór, który służy do wyszukiwania tekstu bezpośrednio do całego tekstu, jeśli {{Code|czy_granicznie{{=}}true}}, a gdy nie, to ta zmienna musi przyjmować wartość {{Code|nil}} lub {{Code|false}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function GranicznieSzereg(wzor,czy_granicznie)...end; </syntaxhighlight> Parametry funkcji: * {{Code|wzor}} - produkuje wzor, który nie dopasowuje domyślnie do całego ciągu znakowego, * {{Code|czy_granicznie}} - robi ze wzoru wyrażenie regularne dopasowujące do całego ciągu znakowego. Przykład użycia funkcji: <syntaxhighlight lang="lua"> local wzor="%[%[.-%]%]"; local wzor2=GranicznieSzereg(wzor,true); </syntaxhighlight> Funkcja zwraca wynik {{Code|wzór2{{=}}"^%[%[.-%]%]$"}}. A gdy drugi parametr jest np. równy {{Code|nil}} lub {{Code|false}}, wtedy funkcja nie zmienia podanego wzoru, tylko go powtarza. == {{Code|p.ZnakiSpecjalneAnulowaniaIchZnaczeniaTagowegoMediaWiki()}} == Funkcja zmienia tagi znaczników, tzn. w nich znaki: {{Code|<}} i {{Code|>}}, na odpowiednie szablony, według podanego w module: {{Code|{{ld2|Specjalne/dane}}}}, kodu: <syntaxhighlight lang="lua"> local p={} p.szablony_anulowania_znaczeniowego_tagowego_mediawiki={ ["<"]="{{Mniejszy}}", [">"]="{{Większy}}", }; </syntaxhighlight> Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneAnulowaniaIchZnaczeniaTagowegoMediaWiki(szablon)...end; </syntaxhighlight> Parametry funkcji: * {{Code|szablon}} - tekst, w którym znaki specjalne {{Code|<nowiki><></nowiki>}} są zamieniane na wywołania szablonowe kolejno: {{s|Mniejszy}} i {{s|Większy}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="<nowiki>Oto jest tekst</nowiki>"; local tekst2=specjalne_modul.ZnakiSpecjalneAnulowaniaIchZnaczeniaTagowegoMediaWiki(tekst); </syntaxhighlight> Wynikiem tego kodu jest tekst ukryty pod zmienną {{Code|tekst2}}: <syntaxhighlight lang="lua"> local tekst2="{{Mniejszy}}nowiki{{Większy}}Oto jest tekst{{Mniejszy}}/nowiki{{Większy}}"; </syntaxhighlight> Ta funkcja wyłącza znaczenie specjalnych tagów mechanizmu {{Strong|MediaWiki}}, i je jako swoje on nie interpretuje, jedynie rozpatruje to jako zwykły tekst. Taki tekst można włączyć do funkcji {{Code|frame:preprocess}}, wtedy jedynie szablony {{s|Mniejszy}} i {{s|Większy}} zostaną rozwinięte, nie naruszając magiczności tych tagów. Tę funkcję jedynie się stosuje wtedy, gdy chcemy, by te tagi nie zostały zamienione na specjalne kody {{Strong|MediaWiki}} tego mechanizmu. Tak robimy, by później dało je usunąć bardzo łatwo, nie naruszając ich zawartości. == {{Code|p["UsuńŚciśleOkreśloneKategorie"](frame)}} == Szablon usuwa ściśle określone kategorie z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńŚciśleOkreśloneKategorie"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|kategoria}} - parametr mówiący jakie kategorie usunąć o takim samym adresie, w przypadku niepodania tego parametru, używane jest domyślne dopasowanie do wszystkich kategorii według wzoru {{Code|<nowiki>([^%[%]|]*)</nowiki>}}, * {{Code|3}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Funkcja dopasowuje kategorie opisane przez nazwę kanoniczną: {{Code|Category}}, lub niekanoniczną: {{Code|Kategoria}}, niezależnie, czy takie wywołanie posiada nazwę sortowania, czy nie. Funkcja usuwa kategorie o danej nazwie, niezależnie jak ona została podana z iloma odstępami, czy dolnymi myślnikami, na jego początku, końcu, a nawet wewnątrz. Funkcja ustawia tak zmienną {{Code|kategoria}}, a właściwie ją przekształca, jeżeli została podana, tzn. zbędne myślniki i odstępy na początku i końcu z niej są usuwane, a wewnątrz je zostają zastąpione w niej przez wyrażenie: {{Code|[%s_]+}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego kategorie: [[Category:Nazwa kategorii|Nazwa sortowania 1]], i następna: [[Kategoria:Nazwa kategorii|Nazwa sortowania 2]]"; local kategoria="Nazwa kategorii"; local granicznie=""; local tekst2=specjalne_modul["UsuńŚciśleOkreśloneKategorie"]{tekst=tekst,kategoria=kategoria,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[[Category:Nazwa kategorii|Nazwa sortowania 1]]</nowiki>}} i {{Code|<nowiki>[[Kategoria:Nazwa kategorii|Nazwa sortowania 2]]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego kategorie: , i następna: "; </syntaxhighlight> == {{Code|p["UsuńKategorie"](frame)}} == Szablon usuwa wszystkie kategorie z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńKategorie"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego kategorie: [[Category:Nazwa kategorii|Nazwa sortowania 1]], i następna: [[Kategoria:Nazwa kategorii|Nazwa sortowania 2]]"; local granicznie=""; local tekst2=specjalne_modul["UsuńKategorie"]{tekst=tekst,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[[Category:Nazwa kategorii|Nazwa sortowania 1]]</nowiki>}} i {{Code|<nowiki>[[Kategoria:Nazwa kategorii|Nazwa sortowania 2]]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego kategorie: , i następna: "; </syntaxhighlight> == {{Code|p["UsuńZnaczniki"](frame,...)}} == Szablon usuwa wszystkie znaczniki bez zawartości z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńZnaczniki"]=function(frame,jakie,funkcja1,funkcja2)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Parametry typowe dla funkcji: * {{Code|jakie}} - nazwa znacznika, jaka ma być użyta do usuwania z tekstu {{Code|tekst}} znaczników bez zawartości z tym tagiem, w przeciwnym wypadku są usuwane wszystkie znaczniki bez zawartości, * {{Code|funkcja1}} - funkcja wywołana przed usuwaniem znaczników bez zawartości, * {{Code|funkcja2}} - funkcja wywołana po usuwaniu znaczników bez zawartości. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego w niej znaczniki: <span id=\"toc_1\" klasa=\"nazwa_klasy_1\">zawartość pierwsza</span>, i następna: <span id=\"toc _2\" klasa=\"nazwa_klasy_2\">zawartość druga</span>."; local tekst2=specjalne_modul["UsuńZnaczniki"](tekst,"span"); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja jedynie wtedy może być użyta z parametrami ramki. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli znaczniki: {{Code|<nowiki><span id="toc_1" klasa="nazwa_klasy_1"></nowiki>}} i {{Code|<nowiki><span id="toc _2" klasa="nazwa_klasy_2"></nowiki>}} oraz ich znaczniki końcowe, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego w niej znaczniki: zawartość pierwsza, i następna: zawartość druga."; </syntaxhighlight> == {{Code|p["UsuńKomentarze"](frame)}} == Szablon usuwa wszystkie komentarze oznaczone blokiem początkowym {{Code|<nowiki><!--</nowiki>}} i końcowym {{Code|<nowiki>--></nowiki>}}, czyli razem (oznaczając to wyrażeniem regularnym {{lpg|Lua}} w {{lpr|Lua|Scribunto}}): {{Code|<nowiki><!%-%-.-%-%-></nowiki>}}, z tekstu wikikodu, dopasowując do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńKomentarze"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego kategorie w komentarzach: <!--[[Category:Nazwa kategorii|Nazwa sortowania 1]], i następna: [[Kategoria:Nazwa kategorii|Nazwa sortowania 2]]-->"; -- Analogicznie: local tekst2=specjalne_modul["UsuńKomentarze"]{tekst=tekst,}; -- Analogicznie: local tekst2=specjalne_modul["UsuńKomentarze"]{args={tekst=tekst,},}; local tekst2=specjalne_modul["UsuńKomentarze"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja usuwa komentarze z tekstu oznaczonej zmienną {{Code|tekst}}, tworząc nowy tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego kategorie w komentarzach: "; </syntaxhighlight> == {{Code|p["UsuńSzablonyStylów"](frame)}} == Szablon usuwa wszystkie szablony stylów z tekstu wikikodu, dopasowując do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńSzablonyStylów"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego w niej szablony stylów: '\"`UNIQ--templatestyles-00000048-QINU`\"'"; -- Analogicznie: local tekst2=specjalne_modul["UsuńSzablonyStylów"]{tekst=tekst,}; -- Analogicznie: local tekst2=specjalne_modul["UsuńSzablonyStylów"]{args={tekst=tekst,},}; local tekst2=specjalne_modul["UsuńSzablonyStylów"](tekst); </syntaxhighlight> W funkcji do usuwania stylów używana jest funkcja w postaci wywołania: <syntaxhighlight lang="lua"> local szablonowe_modul=require("Module:Szablonowe"); local wzor_stylowy=szablonowe_modul.NormaWzoruKodowaniaTekstu("templatestyles","%w+"); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli szablon stylów w postaci: {{Code|<nowiki>'"`UNIQ--templatestyles-00000048-QINU`"'</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego w niej szablony stylów: "; </syntaxhighlight> == {{Code|p["UsuńWywołaniaPlików"](frame)}} == Szablon usuwa wszystkie wywołania plikowe, oznaczone, np.: {{Code|Image}}, {{Code|Grafika}}, {{Code|File}} i {{Code|Plik}}, z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńWywołaniaPlików"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego wywołania plikowe: [[Plik:Nazwa pliku 1|300x400px|thumb|right|Nazwa opisu dla pliku 1]], i następna: [[File:Nazwa pliku 2|300x400px|thumb|right|Nazwa opisu dla pliku 2]]"; local granicznie=""; local tekst2=specjalne_modul["UsuńWywołaniaPlików"]{tekst=tekst,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[[Plik:Nazwa pliku 1|300x400px|thumb|right|Nazwa opisu dla pliku 1]]</nowiki>}} i {{Code|<nowiki>[[File:Nazwa pliku 2|300x400px|thumb|right|Nazwa opisu dla pliku 2]]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego wywołania plikowe: , i następna: "; </syntaxhighlight> == {{Code|p["UsuńInterwiki"](frame)}} == Szablon usuwa wszystkie interwiki z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńInterwiki"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego interwiki: [[en:w:Nazwa strony 1]], i następna: [[en:w:Nazwa strony 2]]"; local granicznie=""; local tekst2=specjalne_modul["UsuńInterwiki"]{tekst=tekst,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[[en:w:Nazwa strony 1]]</nowiki>}} i {{Code|<nowiki>[[en:w:Nazwa strony 2]]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego interwiki: , i następna: "; </syntaxhighlight> == {{Code|p["UsuńZnakiSpecjalne"](frame)}} == Szablon usuwa wszystkie fragmenty tekstu, oznaczone potrójnym i podwójnym cudzysłowem pojedynczym, z tekstu wikikodu, dopasowując do poszczególnych części tekstu, zastępującje tymi fragmentami, ale bez cudzysłowów, a na samym końcu bezpośrednio usuwamy pozostałości z tymi cudzysłowami. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńZnakiSpecjalne"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest '''''wikikod z cudzysłowami'' i z następnym wikitekstem dalej''', i ''końcowym'''''"; --- Analogicznie: local tekst2=specjalne_modul["UsuńZnakiSpecjalne"]{tekst=tekst,}; --- Analogicznie: local tekst2=specjalne_modul["UsuńZnakiSpecjalne"]{args={tekst=tekst,},}; local tekst2=specjalne_modul["UsuńZnakiSpecjalne"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}} fragmenty tekstuz cudzysłowami i zastępuje je bez cudzysłowów: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod z cudzysłowami i z następnym wikitekstem dalej, i końcowym"; </syntaxhighlight> == {{Code|p["UsuńZbędneBiałeZnaki"](frame)}} == Szablon usuwa wszystkie zbędne białe znaki, na początku i końcu oraz wewnątrz, z tekstu wikikodu, dopasowując do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńZbędneBiałeZnaki"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst=" Oto jest tekst wikikodu. "; -- Analogicznie: local tekst2=specjalne_modul["UsuńZbędneBiałeZnaki"]{tekst=tekst,}; -- Analogicznie: local tekst2=specjalne_modul["UsuńZbędneBiałeZnaki"]{args={tekst=tekst,},}; local tekst2=specjalne_modul["UsuńZbędneBiałeZnaki"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa odstępy początkowe i końcowe oraz powtarzające się w wewnątrz tekstu: <syntaxhighlight lang="lua"> local tekst2="Oto jest tekst wikikodu."; </syntaxhighlight> == {{Code|p["ZamieńLinkiWewnętrzneNaTekst"](frame)}} == Szablon usuwa wszystkie linki wewnętrzne na ich nazwę linku, a jeżeli one tego nie posiadają, to jego adres wewnętrzny, z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ZamieńLinkiWewnętrzneNaTekst"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego linki wewnętrzne: [[:Category:Nazwa kategorii|Nazwa linku 1]], i następna: [[Wikibooks:Nazwa strony projektu]]."; local granicznie=""; local tekst2=specjalne_modul["ZamieńLinkiWewnętrzneNaTekst"]{tekst=tekst,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[[:Category:Nazwa kategorii|Nazwa linku 1]]</nowiki>}} i {{Code|<nowiki>[[Wikibooks:Nazwa strony projektu]]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego linki wewnętrzne: Nazwa linku 1, i następna: Wikibooks:Nazwa strony projektu."; </syntaxhighlight> == {{Code|p["ZamieńLinkiZewnętrzneNaTekst"](frame)}} == Szablon usuwa wszystkie linki zewnętrzne na ich nazwę linku, a jeżeli one tego nie posiadają, to jego adres zewnętrzny, z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ZamieńLinkiZewnętrzneNaTekst"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego linki zewnętrzne: [https://pl.wikibooks.org/wiki/Category:Nazwa kategorii|Nazwa linku 1], i następna: [https://pl.wikibooks.org/wiki/Wikibooks:Nazwa strony projektu]."; local granicznie=""; local tekst2=specjalne_modul["ZamieńLinkiZewnętrzneNaTekst"]{tekst=tekst,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[https://pl.wikibooks.org/wiki/Category:Nazwa kategorii|Nazwa linku 1]</nowiki>}} i {{Code|<nowiki>[https://pl.wikibooks.org/wiki/Wikibooks:Nazwa strony projektu]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego linki zewnętrzne: Nazwa linku 1, i następna: https://pl.wikibooks.org/wiki/Wikibooks:Nazwa strony projektu."; </syntaxhighlight> == {{Code|p["CzyPlik"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, czy jest on dokładnie wywołaniem pliku od początku do końca łańcucha, dopasowując do całości tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyPlik"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="[[Plik:Nazwa pliku.jpg|right|thumb|200x300px|Oto jest opis pliku]]"; -- Równoważne: local czy_tak=specjalne_modul["CzyPlik"]{tekst=tekst,}; -- Równoważne: local czy_tak=specjalne_modul["CzyPlik"]{args={tekst=tekst,},}; local czy_tak=specjalne_modul["CzyPlik"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja jedynie wtedy może być użyta z parametrami ramki. Funkcja w przykładzie z wynik w postaci zmiennej {{Code|czy_tak}} jako ciąg pewien niepusty, a jeżeli to nie jest wywołanie pliku, to uzyskujemy wynik {{Code|nil}}. == {{Code|p["CzyInterwiki"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, czy jest on dokładnie wywołaniem interwiki od początku do końca łańcucha, dopasowując do całości tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyInterwiki"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="[[en:w:Stronana wikipedii]]"; -- Równoważne: local czy_tak=specjalne_modul["CzyInterwiki"]{tekst=tekst,}; -- Równoważne: local czy_tak=specjalne_modul["CzyInterwiki"]{args={tekst=tekst,},}; local czy_tak=specjalne_modul["CzyInterwiki"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja jedynie wtedy może być użyta z parametrami ramki. Funkcja w przykładzie z wynik w postaci zmiennej {{Code|czy_tak}} jako ciąg pewien niepusty, a jeżeli to nie jest wywołanie interwiki, to uzyskujemy wynik {{Code|nil}}. A jeżeli na początku interwiki jest {{Code|pl}}, to wtedy to nie jest jednak interwiki, tylko link wewnętrzny, z samej definicji interwiki. == {{Code|p["CzyAdresLinkuWewnętrznego"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, czy jest on dokładnie adresem linku wewnętrznego od początku do końca łańcucha, dopasowując do całości tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyAdresLinkuWewnętrznego"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|dwukropek}} - czy na początku linku wewnętrznego jest dwukropek, wtedy on na pewno jest linkiem wewnętrznym, a jezeli nie to jest sprawdzane, czy jest tak rzeczywiście, * {{Code|2}}, {{Code|tekst}} lub {{Code|adres}} - tekst, który jest pewnym adresem do sprawdzenia,musi być to adres linku wewnętrznego. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|adres}}, a następnie {{Code|2}}, w przeciwnym wypadku jest sprawdzane ich poszczególnych istnienie pokolei i odpowiednio jest ściągana ich zawartość, w zależności, która zmienna jako pierwsza istnieje. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst=":en:w:Nazwa strony w przestrzeni głównej"; -- Równoważne: local czy_tak=specjalne_modul["CzyAdresLinkuWewnętrznego"](tekst); local czy_tak=specjalne_modul["CzyAdresLinkuWewnętrznego"]{tekst=tekst,dwukropek="",}; </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja jedynie wtedy może być użyta z parametrami ramki. Funkcja w przykładzie z wynik w postaci zmiennej {{Code|czy_tak}} jako ciąg pewien niepusty, a jeżeli to nie jest adresem linku wewnętrznego, to uzyskujemy wynik {{Code|nil}}. == {{Code|p["CzyLinkWewnętrzny"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, czy jest on dokładnie wywołaniem linku wewnętrznego od początku do końca łańcucha, dopasowując do całości tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyLinkWewnętrzny"]=function(szablon)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="[[:en:w:Nazwa strony w przestrzeni głównej|Oto jest nazwa linku]]"; -- Równoważne: local czy_tak=specjalne_modul["CzyLinkWewnętrzny"]{tekst=tekst,}; -- Równoważne: local czy_tak=specjalne_modul["CzyLinkWewnętrzny"]{args={tekst=tekst,},}; local czy_tak=specjalne_modul["CzyLinkWewnętrzny"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja jedynie wtedy może być użyta z parametrami ramki. Funkcja w przykładzie z wynik w postaci zmiennej {{Code|czy_tak}} jako ciąg pewien niepusty, a jeżeli to nie jest wywołanie linku wewnętrznego, to uzyskujemy wynik {{Code|nil}}. == {{Code|p["WydzielZwykłyTekst"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, i wydziela tekst z elementów mechanizmu MediaWiki wikikodu wolnego jego od elementów, w tym linki wewnętrzne, zewnętrzne, i inne. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["WydzielZwykłyTekst"]=function(frame,funkcja1,funkcja2)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|nieklasycznie}} - wartość pusta lub niepodana oznacza, że ma rozwijać {{Code|tekst}} (lub {{Code|1}}), jak leci, bez ładowania potężnych szablonów przez mechanizm {{Code|{{M|Szablonowe}}}}, * {{Code|3}} lub {{Code|preprocess}} - czy wikitekst z {{Code|tekst}} (lub {{Code|1}}) ma rozwijać, jak szablon, * {{Code|4}} lub {{Code|kodowanie}} - czy wikikod ma kodować według jego zawartości, * {{Code|5}} lub {{Code|nagłówek}} - niepuste, gdy ma nie usuwać znaczników {{Strong|TemplateStyles}}, znaków specjalnych, czyli pojedynczych cudzysłowów, a także znaczników, stosowana niezależnie od wartości {{Code|nieklasycznie}}, * {{Code|6}} lub {{Code|tablica kodowania}} - gdy {{Code|nieklasycznie}} jest niepuste, i {{Code|kodowanie}} ma zawartość pustą, to ta zmienna posiada tablicę kodów {{Code|{{m|Szablonowe}}}}, która posłuży do rozwijania zakodowanego tą metodą tekstu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Parametry funkcji, nie ramki, czyli: * {{Code|funkcja1}} - funkcja zbierająca zawartości kodów i je przekształca w co innego, zwracany szablon, tj. wikikod nowego szablonu z kodami do rozwinięcia przez {{Code|{{m|Szablonowe}}}}, * {{Code|funkcja2}} - kiedy ma rozwinąć ten kod, a może potraktować go jako wartość już rozwiniętą do końca i zwrócić w funkcji rozwijających kody. Gdy {{Code|nieklasycznie}} jest pusta lub niepodana, to funkcja robi operacje zdefiniowane jako przez funkcje: <syntaxhighlight lang="lua"> local function DwaNawiasyLinkowe(tekst) tekst=p["UsuńKategorie"]{tekst,nieklasycznie,}; tekst=p["UsuńWywołaniaPlików"]{tekst,nieklasycznie,}; tekst=p["UsuńInterwiki"]{tekst,nieklasycznie,}; tekst=p["ZamieńLinkiWewnętrzneNaTekst"]{tekst,nieklasycznie,}; return tekst; end; local function JedenNawiasLinkowe(tekst) tekst=p["ZamieńLinkiZewnętrzneNaTekst"]{tekst,nieklasycznie,}; return tekst; end; local function Komentarze(tekst) tekst=p["UsuńKomentarze"](tekst); return tekst; end; local function SzablonyStylowe(tekst) tekst=p["UsuńSzablonyStylów"](tekst); return tekst; end; local function ZnakiSpecjalne(tekst) tekst=p["UsuńZnakiSpecjalne"](tekst); return tekst; end; local function Znaczniki(tekst,jakie,__FUNKCJA1,__FUNKCJA2) tekst=p["UsuńZnaczniki"](tekst,jakie,__FUNKCJA1,__FUNKCJA2); return tekst; end; local function PreProcessFrame(tekst) local frame=mw.getCurrentFrame(); frame=frame.getParent and frame:getParent() or frame; tekst=frame:preprocess(tekst); return tekst; end; </syntaxhighlight> oprócz operacji: {{Code|SzablonyStylowe(tekst)}}, {{Code|ZnakiSpecjalne(tekst)}} i {{Code|Znaczniki(tekst,jakie,__FUNKCJA1,__FUNKCJA2)}}, gdy {{Code|nagłówek}} jest pusty lub niepodany, wtedy zwracany jest tekst, i kolejno te funkcje, a w przypadku przeciwnej wartości tej zmiennej jest zwracany tylko tekst. Perzy okazji można przez niepustej zmiennej {{Code|preproces}} znaki specjalne znaczników są zamieniane na szablony: {{s|Mniejszy}} i {{s|Większy}}, przy pomocy funkcji: {{Code|tekst{{=}}p.ZnakiSpecjalneAnulowaniaIchZnaczeniaTagowegoMediaWiki(tekst)}}, a następnie rozwijany jest funkcją {{Code|PreProcessFrame(tekst)}} przy wyłączeniu znaczenia znaczniki mechanizmu MediaWiki, nie HTML (bo są to dwie różne sprawy), ta operacja kjest robiona przed operacją przekształcania zmiennej wikikodu. Gdy {{Code|nieklasycznie}} przyjmuje wartość niepustą, wtedy moznaa zakodować tekst wikikodu, przy użyciu niepustej wartości {{Code|kodowanie}}, a przy innej wikikod powinien już być zakodowany na samym wyjściu. Gdy mamy obiekty w rozwijaniu przy pomocy {{Code|{{m|Szablonowe}}}}, można wygenerować nową zawartość szablonu, sprawdzić, czy ona się zgadza instrukcją: <syntaxhighlight lang="lua"> if(((not funkcja1) or (szablon))and((not funkcja2) or funkcja2(szablon,obiekt,kod)))then </syntaxhighlight> i dalej go przekształcać, przy zmiennej {{Code|nagłówek}} nie pustej, pozostawiając kody atrybutów, znaczników, i obiektów określonych normą: <syntaxhighlight lang="lua"> if((obiekt=="NOWIKI")or(obiekt=="MATH")or(obiekt=="ŹRÓDŁO")or(obiekt=="GALERIA")or(obiekt=="MAPAOBRAZU")or(obiekt=="PUDEŁKOWEJŚCIA")or(obiekt=="QUIZ"))then </syntaxhighlight> Po uzyskaniu tak rozwiniętego kody, przy zmiennej {{Code|nagłówek}} niepustej, wtedy zostaje nie zostaną wywołane funkcje: {{Code|tekst{{=}}SzablonyStylowe(tekst)}} i {{Code|tekst{{=}}ZnakiSpecjalne(tekst)}}, ale one zostają zwrócone po kolei wraz z wikikodem w pierwszej kolejności i dalej kolejno te funkcje. A gdy jednak ta pierwsza zmienna w tej linijce zostanie pusta lub niepodana, wtedy zwracany jest sam czysty rozwinięty i oczyszczony tekst. W module {{Code|{{ld2|StronicowyParser/GłównaFunkcjaZbieraniaDanychStron}}}}, wywoływana jest funkcja: <syntaxhighlight lang="lua"> local naglowek,Znaczniki,SzablonyStylowe,ZnakiSpecjalne=specjalne_modul["WydzielZwykłyTekst"]( { -- Wikitekst z elementami mechanizmu MediaWiki tekst=naglowek, -- Zwróć test i funkcje, które muszą coś zrobić; ["nagłówek"]=true, -- Rób operacje według drugiego sposobu rozwijania z dwóch dostępnych; nieklasycznie=true, -- Ma nie kodować wikitekstu kodowanie=false, -- Gotowa tablica kodowania wikitekstu tekst; ["tablica kodowania"]=tablica_analizy_obiektow_strony_dany_modul, }, -- Funkcja: funkcja1; function(szablon,obiekt,kod) local szablon,wynik=SzablonyWywolywane(szablon,obiekt,kod); return szablon,wynik; end, --- Funkcja: funkcja2; function(szablon,obiekt,kod) return czy_indeksowanie; end); </syntaxhighlight> która oczyszcza tekst potrzebnymi funkcjami, zwracając również funkcje,które muszą dokonać dalszej roboty, jeżeli będzie ona potrzebna w jakieś formie. == {{Code|p["WydzielLiczbę"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, i wydziela tekst z elementów mechanizmu wikikodu, w tym linki wewnętrzne, zewnętrzne, i inne. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["WydzielLiczbę"] = function(frame)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Funkcja do swojego działania wykorzystuje funkcję {{Code|{{sr|#p["WydzielZwykłyTekst"](frame)|p=Specjalne}}}}, i wydziela z niej liczbę i ją zwraca w postaci przekłształconej do liczby przy pomocy funkcji {{Code|tunumber}}, a jeżeli takiej liczby nie znalazł, to zwraca {{Code|nil}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="[[:en:w:Wikipedia:Strona projektu wikipdii|Link +547 567 567]]"; -- Równoważnie: local liczba=specjalne_modul["WydzielLiczbę"]{tekst=tekst,}; -- Równoważnie: local liczba=specjalne_modul["WydzielLiczbę"]{args={tekst=tekst,},}; local liczba=specjalne_modul["WydzielLiczbę"](tekst); </syntaxhighlight> Funkcja zwraca liczbę po usunięciu odstępów w postaci zmiennej typu {{Code|number}}: <syntaxhighlight lang="lua"> local liczba=547567567; </syntaxhighlight> Fukcja jest wykorzystywana w funkcji: {{Code|{{sr|#p["Forma wyrażenia po liczbie"](frame)|p=Techniczne}}}}, a więc i jednocześnie w szablonie: {{s|Forma wyrażenia po liczbie}} i jego pokrewnych z niej wynikających. == {{Code|p["PrzetwórzNagłówek"](...)}} == Szablon sprawdza zawartość tekstu wikikodu, i wydziela z niego adres linku wewnętrznego i nazwę linku (nagłówka). Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["PrzetwórzNagłówek"]=function(adres,czy_naglowek_linku,czy_nie_rozwin_adres)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - czy ma liczyć tylko adres (wartość typu {{Strong|string}}) * {{Code|czy_naglowek_linku}} - czy ma liczyc nagłówek linku (wartość typu {{Strong|boolean}}), * {{Code|czy_nie_rozwin_adres}} - czy adres linku ma rozwijać funkcją {{Code|frame:preprocess}} (wartość typu {{Strong|boolean}}). Funkcja używa do swojego działania {{Code|{{sr|#p["WydzielZwykłyTekst"](frame)|p=Specjalne}}}} do wydzielania tekstu, zwraca tutaj przetworzony tekst wydzielony z elementów mechanizmu {{Strong|MediaWiki}}, oprócz zastosowania funkcji: {{Code|Znaczniki}}, {{Code|SzablonyStylowe}} i {{Code|ZnakiSpecjalne}}, które zostaną zastosowane do zwracanej pierwszej wartości podczas liczenia adresu, a podczas liczenia nagłówka tylko funkcja {{Code|Znaczniki}} zostanie zastosowana, ale tylko dla niektórych elementów, a nie dla wszystkich, a za to dla pierwszej, wręcz przeciwnie, dla wszystkich. Przykład: <syntaxhighlight lang="lua"> local adres,naglowek=specjalne_modul["PrzetwórzNagłówek"](adres,true,false); </syntaxhighlight> Funkcja liczy adres linku i nazwę linku (naglowka) linku, które są zwracane kolejno w postaci dwóch zwracanych zmiennych, mając jedynie nieprzetworzony adres w wikikodzie, z prawdopodobnie z elementami mechanizmu MediaWiki, co po zwróceniu dwóch zmiennych otrzymujemy oczyszczony z elementów mechanizmu {{Strong|MediaWiki}} i {{Strong|HTML}}, tak jest w przypadku zmiennej {{Code|adres}}, a dla {{Code|naglowek}} jedynie zawiera niektóre elementy znaczników {{Strong|HTML}}, elementy takie jak: {{Tag|ol}}, {{Code|ul}} i {{Code|li}}, w tej funkcji są usuwane z nagłówka elementu nazwy linku, a inne znaczniki, te które są również znacznikkami {{Strong|HTML}} w mechanizmie nie są usuwane, w tym również znacznik {{Tag|pre}}, który jest jednocześnie znacznikiem {{Strong|HTML}} i znacznikiem mechanizmu {{Strong|MediaWiki}}. == {{Code|p["OdstępyZmiennychNumerowanychSzablonu"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, i wydziela domyślnie prawe odstępy od czarnych znaków wikikodu, w przeciwnym wypadku po podaniu pewnej zmiennej niepustej lewą. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["OdstępyZmiennychNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} - zawartość tekstu z wikikodem * {{Code|lewy}} - czy ma wydzielać lewe odstępy w tekście {{Code|1}}, jeśli niepsuta, w przeciwnym wypadku prawą. Zwykłe szablony mają takę funkcję, że trimują zawartość zmiennej nienazwanej {{Code|1}}, jeżeli ją wsadzono do szablonu do zmiennej nazwanej, a więc wtedy jest konieczne używanie tejże funkcji w wikikodzie w szablonie, aby napisać jego lewe i prawe odstępy. To uwzględnia poniższy przykład: {{ŹródłoKodu|język=mediawiki|{{LuaSubst|{{ns:Template}}:L|inkludowana=tak}}}} Jest to kod przykładowego szablonu przekopiowany z: {{s|l}}, gdzie użycie tejże funkcji jest jednak konieczne. Funkcja kolejno w wywołaniach wydziela lewe a potem prawe odstępy zmiennej {{Code|1}}, przy użyciu parametru {{Parametr|wyspecjalizowana|tak}}. Funkcja produkuje link wewnętrzny za pomocą szablonu {{s|Link wewnętrzny}}, która ucina odstępy na początku i końcu zmiennej {{Code|s}}, a niekoniecznie {{Code|1}}. Przed i po linku są ustawiane odstępy, aby zachować historie produkowanych szablonów, jeżeli przeprowadzamy wizualizację danego szablonu. Szablonem do oglądania jego jest: {{s|PreWikikod}}, w którym jest ukryta funkcja {{Code|{{m|Techniczne|Wikikod}}}}. W tym szablonie jest ukryty inny szablon, a mianowicie {{s|Pre}}, dlatego jest zachowana historia, co do odstępów, i nowych linii, wikikodu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> qas7f2ftmw249nwtv1vwarllqzq73xw 541356 541349 2026-04-30T08:23:15Z Persino 2851 541356 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Specjalne}}|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 specjalne_modul=require("Module:Specjalne"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. Funkcje w tym module służą do specjalnych celów do obsługi na tekstach, nie tak jak {{Code|{{ld2|Szeregi}}}} (modyfikuje tekst, nawet w liniach), czy {{Code|{{ld2|Strony}}}} (która sprawdza wartość tekstową), a nawet {{Code|{{ld2|Parametry}}}} (do obsługi parametrów), albo {{Code|{{ld2|Html}}}} (do obsługi na tekstach związanych ze stronami HTML). Te funkcje służą do operacji na tekstach związanych z mechanizmem {{Strong|MediaWiki}}. == {{Code|GranicznieSzereg()}} == Jest to funkcja lokalna w module {{Code|{{ld2|Specjalne}}}}, używana tylko wewnątrz funkcji należących do jego tablicy transportu. Funkcja ustawia tak wzór, który służy do wyszukiwania tekstu bezpośrednio do całego tekstu, jeśli {{Code|czy_granicznie{{=}}true}}, a gdy nie, to ta zmienna musi przyjmować wartość {{Code|nil}} lub {{Code|false}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> local function GranicznieSzereg(wzor,czy_granicznie)...end; </syntaxhighlight> Parametry funkcji: * {{Code|wzor}} - produkuje wzor, który nie dopasowuje domyślnie do całego ciągu znakowego, * {{Code|czy_granicznie}} - robi ze wzoru wyrażenie regularne dopasowujące do całego ciągu znakowego. Przykład użycia funkcji: <syntaxhighlight lang="lua"> local wzor="%[%[.-%]%]"; local wzor2=GranicznieSzereg(wzor,true); </syntaxhighlight> Funkcja zwraca wynik {{Code|wzór2{{=}}"^%[%[.-%]%]$"}}. A gdy drugi parametr jest np. równy {{Code|nil}} lub {{Code|false}}, wtedy funkcja nie zmienia podanego wzoru, tylko go powtarza. == {{Code|p.ZnakiSpecjalneAnulowaniaIchZnaczeniaTagowegoMediaWiki()}} == Funkcja zmienia tagi znaczników, tzn. w nich znaki: {{Code|<}} i {{Code|>}}, na odpowiednie szablony, według podanego w module: {{Code|{{ld2|Specjalne/dane}}}}, kodu: <syntaxhighlight lang="lua"> local p={} p.szablony_anulowania_znaczeniowego_tagowego_mediawiki={ ["<"]="{{Mniejszy}}", [">"]="{{Większy}}", }; </syntaxhighlight> Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZnakiSpecjalneAnulowaniaIchZnaczeniaTagowegoMediaWiki(szablon)...end; </syntaxhighlight> Parametry funkcji: * {{Code|szablon}} - tekst, w którym znaki specjalne {{Code|<nowiki><></nowiki>}} są zamieniane na wywołania szablonowe kolejno: {{s|Mniejszy}} i {{s|Większy}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="<nowiki>Oto jest tekst</nowiki>"; local tekst2=specjalne_modul.ZnakiSpecjalneAnulowaniaIchZnaczeniaTagowegoMediaWiki(tekst); </syntaxhighlight> Wyniki działania: <syntaxhighlight lang="lua"> local tekst2="{{Mniejszy}}nowiki{{Większy}}Oto jest tekst{{Mniejszy}}/nowiki{{Większy}}"; </syntaxhighlight> Ta funkcja wyłącza znaczenie specjalnych tagów mechanizmu {{Strong|MediaWiki}}, i je jako swoje on nie interpretuje, jedynie rozpatruje to jako zwykły tekst. Taki tekst można włączyć do funkcji {{Code|frame:preprocess}}, wtedy jedynie szablony {{s|Mniejszy}} i {{s|Większy}} zostaną rozwinięte, nie naruszając magiczności tych tagów. Tę funkcję jedynie się stosuje wtedy, gdy chcemy, by te tagi nie zostały zamienione na specjalne kody {{Strong|MediaWiki}} tego mechanizmu. Tak robimy, by później dało je usunąć bardzo łatwo, nie naruszając ich zawartości. == {{Code|p["UsuńŚciśleOkreśloneKategorie"](frame)}} == Szablon usuwa ściśle określone kategorie z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńŚciśleOkreśloneKategorie"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|kategoria}} - parametr mówiący jakie kategorie usunąć o takim samym adresie, w przypadku niepodania tego parametru, używane jest domyślne dopasowanie do wszystkich kategorii według wzoru {{Code|<nowiki>([^%[%]|]*)</nowiki>}}, * {{Code|3}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Funkcja dopasowuje kategorie opisane przez nazwę kanoniczną: {{Code|Category}}, lub niekanoniczną: {{Code|Kategoria}}, niezależnie, czy takie wywołanie posiada nazwę sortowania, czy nie. Funkcja usuwa kategorie o danej nazwie, niezależnie jak ona została podana z iloma odstępami, czy dolnymi myślnikami, na jego początku, końcu, a nawet wewnątrz. Funkcja ustawia tak zmienną {{Code|kategoria}}, a właściwie ją przekształca, jeżeli została podana, tzn. zbędne myślniki i odstępy na początku i końcu z niej są usuwane, a wewnątrz je zostają zastąpione w niej przez wyrażenie: {{Code|[%s_]+}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego kategorie: [[Category:Nazwa kategorii|Nazwa sortowania 1]], i następna: [[Kategoria:Nazwa kategorii|Nazwa sortowania 2]]"; local kategoria="Nazwa kategorii"; local granicznie=""; local tekst2=specjalne_modul["UsuńŚciśleOkreśloneKategorie"]{tekst=tekst,kategoria=kategoria,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[[Category:Nazwa kategorii|Nazwa sortowania 1]]</nowiki>}} i {{Code|<nowiki>[[Kategoria:Nazwa kategorii|Nazwa sortowania 2]]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego kategorie: , i następna: "; </syntaxhighlight> == {{Code|p["UsuńKategorie"](frame)}} == Szablon usuwa wszystkie kategorie z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńKategorie"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego kategorie: [[Category:Nazwa kategorii|Nazwa sortowania 1]], i następna: [[Kategoria:Nazwa kategorii|Nazwa sortowania 2]]"; local granicznie=""; local tekst2=specjalne_modul["UsuńKategorie"]{tekst=tekst,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[[Category:Nazwa kategorii|Nazwa sortowania 1]]</nowiki>}} i {{Code|<nowiki>[[Kategoria:Nazwa kategorii|Nazwa sortowania 2]]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego kategorie: , i następna: "; </syntaxhighlight> == {{Code|p["UsuńZnaczniki"](frame,...)}} == Szablon usuwa wszystkie znaczniki bez zawartości z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńZnaczniki"]=function(frame,jakie,funkcja1,funkcja2)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Parametry typowe dla funkcji: * {{Code|jakie}} - nazwa znacznika, jaka ma być użyta do usuwania z tekstu {{Code|tekst}} znaczników bez zawartości z tym tagiem, w przeciwnym wypadku są usuwane wszystkie znaczniki bez zawartości, * {{Code|funkcja1}} - funkcja wywołana przed usuwaniem znaczników bez zawartości, * {{Code|funkcja2}} - funkcja wywołana po usuwaniu znaczników bez zawartości. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego w niej znaczniki: <span id=\"toc_1\" klasa=\"nazwa_klasy_1\">zawartość pierwsza</span>, i następna: <span id=\"toc _2\" klasa=\"nazwa_klasy_2\">zawartość druga</span>."; local tekst2=specjalne_modul["UsuńZnaczniki"](tekst,"span"); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja jedynie wtedy może być użyta z parametrami ramki. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli znaczniki: {{Code|<nowiki><span id="toc_1" klasa="nazwa_klasy_1"></nowiki>}} i {{Code|<nowiki><span id="toc _2" klasa="nazwa_klasy_2"></nowiki>}} oraz ich znaczniki końcowe, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego w niej znaczniki: zawartość pierwsza, i następna: zawartość druga."; </syntaxhighlight> == {{Code|p["UsuńKomentarze"](frame)}} == Szablon usuwa wszystkie komentarze oznaczone blokiem początkowym {{Code|<nowiki><!--</nowiki>}} i końcowym {{Code|<nowiki>--></nowiki>}}, czyli razem (oznaczając to wyrażeniem regularnym {{lpg|Lua}} w {{lpr|Lua|Scribunto}}): {{Code|<nowiki><!%-%-.-%-%-></nowiki>}}, z tekstu wikikodu, dopasowując do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńKomentarze"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego kategorie w komentarzach: <!--[[Category:Nazwa kategorii|Nazwa sortowania 1]], i następna: [[Kategoria:Nazwa kategorii|Nazwa sortowania 2]]-->"; -- Analogicznie: local tekst2=specjalne_modul["UsuńKomentarze"]{tekst=tekst,}; -- Analogicznie: local tekst2=specjalne_modul["UsuńKomentarze"]{args={tekst=tekst,},}; local tekst2=specjalne_modul["UsuńKomentarze"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja usuwa komentarze z tekstu oznaczonej zmienną {{Code|tekst}}, tworząc nowy: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego kategorie w komentarzach: "; </syntaxhighlight> == {{Code|p["UsuńSzablonyStylów"](frame)}} == Szablon usuwa wszystkie szablony stylów z tekstu wikikodu, dopasowując do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńSzablonyStylów"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego w niej szablony stylów: '\"`UNIQ--templatestyles-00000048-QINU`\"'"; -- Analogicznie: local tekst2=specjalne_modul["UsuńSzablonyStylów"]{tekst=tekst,}; -- Analogicznie: local tekst2=specjalne_modul["UsuńSzablonyStylów"]{args={tekst=tekst,},}; local tekst2=specjalne_modul["UsuńSzablonyStylów"](tekst); </syntaxhighlight> W funkcji do usuwania stylów używana jest funkcja w postaci wywołania: <syntaxhighlight lang="lua"> local szablonowe_modul=require("Module:Szablonowe"); local wzor_stylowy=szablonowe_modul.NormaWzoruKodowaniaTekstu("templatestyles","%w+"); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli szablon stylów w postaci: {{Code|<nowiki>'"`UNIQ--templatestyles-00000048-QINU`"'</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego w niej szablony stylów: "; </syntaxhighlight> == {{Code|p["UsuńWywołaniaPlików"](frame)}} == Szablon usuwa wszystkie wywołania plikowe, oznaczone, np.: {{Code|Image}}, {{Code|Grafika}}, {{Code|File}} i {{Code|Plik}}, z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńWywołaniaPlików"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego wywołania plikowe: [[Plik:Nazwa pliku 1|300x400px|thumb|right|Nazwa opisu dla pliku 1]], i następna: [[File:Nazwa pliku 2|300x400px|thumb|right|Nazwa opisu dla pliku 2]]"; local granicznie=""; local tekst2=specjalne_modul["UsuńWywołaniaPlików"]{tekst=tekst,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[[Plik:Nazwa pliku 1|300x400px|thumb|right|Nazwa opisu dla pliku 1]]</nowiki>}} i {{Code|<nowiki>[[File:Nazwa pliku 2|300x400px|thumb|right|Nazwa opisu dla pliku 2]]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego wywołania plikowe: , i następna: "; </syntaxhighlight> == {{Code|p["UsuńInterwiki"](frame)}} == Szablon usuwa wszystkie interwiki z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńInterwiki"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego interwiki: [[en:w:Nazwa strony 1]], i następna: [[en:w:Nazwa strony 2]]"; local granicznie=""; local tekst2=specjalne_modul["UsuńInterwiki"]{tekst=tekst,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[[en:w:Nazwa strony 1]]</nowiki>}} i {{Code|<nowiki>[[en:w:Nazwa strony 2]]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego interwiki: , i następna: "; </syntaxhighlight> == {{Code|p["UsuńZnakiSpecjalne"](frame)}} == Szablon usuwa wszystkie fragmenty tekstu, oznaczone potrójnym i podwójnym cudzysłowem pojedynczym, z tekstu wikikodu, dopasowując do poszczególnych części tekstu, zastępującje tymi fragmentami, ale bez cudzysłowów, a na samym końcu bezpośrednio usuwamy pozostałości z tymi cudzysłowami. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńZnakiSpecjalne"] = function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest '''''wikikod z cudzysłowami'' i z następnym wikitekstem dalej''', i ''końcowym'''''"; --- Analogicznie: local tekst2=specjalne_modul["UsuńZnakiSpecjalne"]{tekst=tekst,}; --- Analogicznie: local tekst2=specjalne_modul["UsuńZnakiSpecjalne"]{args={tekst=tekst,},}; local tekst2=specjalne_modul["UsuńZnakiSpecjalne"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}} fragmenty tekstuz cudzysłowami i zastępuje je bez cudzysłowów: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod z cudzysłowami i z następnym wikitekstem dalej, i końcowym"; </syntaxhighlight> == {{Code|p["UsuńZbędneBiałeZnaki"](frame)}} == Szablon usuwa wszystkie zbędne białe znaki, na początku i końcu oraz wewnątrz, z tekstu wikikodu, dopasowując do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UsuńZbędneBiałeZnaki"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst=" Oto jest tekst wikikodu. "; -- Analogicznie: local tekst2=specjalne_modul["UsuńZbędneBiałeZnaki"]{tekst=tekst,}; -- Analogicznie: local tekst2=specjalne_modul["UsuńZbędneBiałeZnaki"]{args={tekst=tekst,},}; local tekst2=specjalne_modul["UsuńZbędneBiałeZnaki"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa odstępy początkowe i końcowe oraz powtarzające się w wewnątrz tekstu: <syntaxhighlight lang="lua"> local tekst2="Oto jest tekst wikikodu."; </syntaxhighlight> == {{Code|p["ZamieńLinkiWewnętrzneNaTekst"](frame)}} == Szablon usuwa wszystkie linki wewnętrzne na ich nazwę linku, a jeżeli one tego nie posiadają, to jego adres wewnętrzny, z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ZamieńLinkiWewnętrzneNaTekst"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego linki wewnętrzne: [[:Category:Nazwa kategorii|Nazwa linku 1]], i następna: [[Wikibooks:Nazwa strony projektu]]."; local granicznie=""; local tekst2=specjalne_modul["ZamieńLinkiWewnętrzneNaTekst"]{tekst=tekst,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[[:Category:Nazwa kategorii|Nazwa linku 1]]</nowiki>}} i {{Code|<nowiki>[[Wikibooks:Nazwa strony projektu]]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego linki wewnętrzne: Nazwa linku 1, i następna: Wikibooks:Nazwa strony projektu."; </syntaxhighlight> == {{Code|p["ZamieńLinkiZewnętrzneNaTekst"](frame)}} == Szablon usuwa wszystkie linki zewnętrzne na ich nazwę linku, a jeżeli one tego nie posiadają, to jego adres zewnętrzny, z tekstu wikikodu, dopasowując do całości lub do poszczególnych części tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ZamieńLinkiZewnętrzneNaTekst"]=function(frame)...end; </syntaxhighlight> Parametry funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|granicznie}} - wskazujący, czy dopasować do całości (jeśli niepusta), czy w przeciwnym wypadku do poszczególnych części wikikodu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, czy {{Code|tekst}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="Oto jest wikikod i jego linki zewnętrzne: [https://pl.wikibooks.org/wiki/Category:Nazwa kategorii|Nazwa linku 1], i następna: [https://pl.wikibooks.org/wiki/Wikibooks:Nazwa strony projektu]."; local granicznie=""; local tekst2=specjalne_modul["ZamieńLinkiZewnętrzneNaTekst"]{tekst=tekst,granicznie=granicznie,}; </syntaxhighlight> Funkcja {{Code|{{sr|#p.CzyTak(...)|p=Parametry}}}}, tłumaczy wartość tekstową zmiennej {{Code|graniecznie}} na wartość {{Code|tak}} lub {{Code|nil}}, w przypadku niepodania tej zmiennej, to to tłumaczenie jest na tą ostatnią wartość. Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Powyższe wywołanie usuwa wywołanie z wikikodu ze zmiennej {{Code|tekst}}, czyli kategorie: {{Code|<nowiki>[https://pl.wikibooks.org/wiki/Category:Nazwa kategorii|Nazwa linku 1]</nowiki>}} i {{Code|<nowiki>[https://pl.wikibooks.org/wiki/Wikibooks:Nazwa strony projektu]</nowiki>}}, stąd pozostaje tylko tekst: <syntaxhighlight lang="lua"> local tekst2="Oto jest wikikod i jego linki zewnętrzne: Nazwa linku 1, i następna: https://pl.wikibooks.org/wiki/Wikibooks:Nazwa strony projektu."; </syntaxhighlight> == {{Code|p["CzyPlik"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, czy jest on dokładnie wywołaniem pliku od początku do końca łańcucha, dopasowując do całości tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyPlik"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="[[Plik:Nazwa pliku.jpg|right|thumb|200x300px|Oto jest opis pliku]]"; -- Równoważne: local czy_tak=specjalne_modul["CzyPlik"]{tekst=tekst,}; -- Równoważne: local czy_tak=specjalne_modul["CzyPlik"]{args={tekst=tekst,},}; local czy_tak=specjalne_modul["CzyPlik"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja jedynie wtedy może być użyta z parametrami ramki. Funkcja w przykładzie z wynik w postaci zmiennej {{Code|czy_tak}} jako ciąg pewien niepusty, a jeżeli to nie jest wywołanie pliku, to uzyskujemy wynik {{Code|nil}}. == {{Code|p["CzyInterwiki"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, czy jest on dokładnie wywołaniem interwiki od początku do końca łańcucha, dopasowując do całości tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyInterwiki"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="[[en:w:Stronana wikipedii]]"; -- Równoważne: local czy_tak=specjalne_modul["CzyInterwiki"]{tekst=tekst,}; -- Równoważne: local czy_tak=specjalne_modul["CzyInterwiki"]{args={tekst=tekst,},}; local czy_tak=specjalne_modul["CzyInterwiki"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja jedynie wtedy może być użyta z parametrami ramki. Funkcja w przykładzie z wynik w postaci zmiennej {{Code|czy_tak}} jako ciąg pewien niepusty, a jeżeli to nie jest wywołanie interwiki, to uzyskujemy wynik {{Code|nil}}. A jeżeli na początku interwiki jest {{Code|pl}}, to wtedy to nie jest jednak interwiki, tylko link wewnętrzny, z samej definicji interwiki. == {{Code|p["CzyAdresLinkuWewnętrznego"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, czy jest on dokładnie adresem linku wewnętrznego od początku do końca łańcucha, dopasowując do całości tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyAdresLinkuWewnętrznego"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|dwukropek}} - czy na początku linku wewnętrznego jest dwukropek, wtedy on na pewno jest linkiem wewnętrznym, a jezeli nie to jest sprawdzane, czy jest tak rzeczywiście, * {{Code|2}}, {{Code|tekst}} lub {{Code|adres}} - tekst, który jest pewnym adresem do sprawdzenia,musi być to adres linku wewnętrznego. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|adres}}, a następnie {{Code|2}}, w przeciwnym wypadku jest sprawdzane ich poszczególnych istnienie pokolei i odpowiednio jest ściągana ich zawartość, w zależności, która zmienna jako pierwsza istnieje. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst=":en:w:Nazwa strony w przestrzeni głównej"; -- Równoważne: local czy_tak=specjalne_modul["CzyAdresLinkuWewnętrznego"](tekst); local czy_tak=specjalne_modul["CzyAdresLinkuWewnętrznego"]{tekst=tekst,dwukropek="",}; </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja jedynie wtedy może być użyta z parametrami ramki. Funkcja w przykładzie z wynik w postaci zmiennej {{Code|czy_tak}} jako ciąg pewien niepusty, a jeżeli to nie jest adresem linku wewnętrznego, to uzyskujemy wynik {{Code|nil}}. == {{Code|p["CzyLinkWewnętrzny"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, czy jest on dokładnie wywołaniem linku wewnętrznego od początku do końca łańcucha, dopasowując do całości tekstu. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["CzyLinkWewnętrzny"]=function(szablon)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="[[:en:w:Nazwa strony w przestrzeni głównej|Oto jest nazwa linku]]"; -- Równoważne: local czy_tak=specjalne_modul["CzyLinkWewnętrzny"]{tekst=tekst,}; -- Równoważne: local czy_tak=specjalne_modul["CzyLinkWewnętrzny"]{args={tekst=tekst,},}; local czy_tak=specjalne_modul["CzyLinkWewnętrzny"](tekst); </syntaxhighlight> Funkcja może być użyta w postaci ramki wikikodu z tymi samymi parametrami, co powyżej, tylko z tą różnicą, że parametry są wsadzane bezpośrednio do tego wywołania, o takiej samej wartości, co w powyższym przykładzie, lub można podać je w postaci zmiennych. Funkcja jedynie wtedy może być użyta z parametrami ramki. Funkcja w przykładzie z wynik w postaci zmiennej {{Code|czy_tak}} jako ciąg pewien niepusty, a jeżeli to nie jest wywołanie linku wewnętrznego, to uzyskujemy wynik {{Code|nil}}. == {{Code|p["WydzielZwykłyTekst"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, i wydziela tekst z elementów mechanizmu MediaWiki wikikodu wolnego jego od elementów, w tym linki wewnętrzne, zewnętrzne, i inne. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["WydzielZwykłyTekst"]=function(frame,funkcja1,funkcja2)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst, * {{Code|2}} lub {{Code|nieklasycznie}} - wartość pusta lub niepodana oznacza, że ma rozwijać {{Code|tekst}} (lub {{Code|1}}), jak leci, bez ładowania potężnych szablonów przez mechanizm {{Code|{{M|Szablonowe}}}}, * {{Code|3}} lub {{Code|preprocess}} - czy wikitekst z {{Code|tekst}} (lub {{Code|1}}) ma rozwijać, jak szablon, * {{Code|4}} lub {{Code|kodowanie}} - czy wikikod ma kodować według jego zawartości, * {{Code|5}} lub {{Code|nagłówek}} - niepuste, gdy ma nie usuwać znaczników {{Strong|TemplateStyles}}, znaków specjalnych, czyli pojedynczych cudzysłowów, a także znaczników, stosowana niezależnie od wartości {{Code|nieklasycznie}}, * {{Code|6}} lub {{Code|tablica kodowania}} - gdy {{Code|nieklasycznie}} jest niepuste, i {{Code|kodowanie}} ma zawartość pustą, to ta zmienna posiada tablicę kodów {{Code|{{m|Szablonowe}}}}, która posłuży do rozwijania zakodowanego tą metodą tekstu. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Parametry funkcji, nie ramki, czyli: * {{Code|funkcja1}} - funkcja zbierająca zawartości kodów i je przekształca w co innego, zwracany szablon, tj. wikikod nowego szablonu z kodami do rozwinięcia przez {{Code|{{m|Szablonowe}}}}, * {{Code|funkcja2}} - kiedy ma rozwinąć ten kod, a może potraktować go jako wartość już rozwiniętą do końca i zwrócić w funkcji rozwijających kody. Gdy {{Code|nieklasycznie}} jest pusta lub niepodana, to funkcja robi operacje zdefiniowane jako przez funkcje: <syntaxhighlight lang="lua"> local function DwaNawiasyLinkowe(tekst) tekst=p["UsuńKategorie"]{tekst,nieklasycznie,}; tekst=p["UsuńWywołaniaPlików"]{tekst,nieklasycznie,}; tekst=p["UsuńInterwiki"]{tekst,nieklasycznie,}; tekst=p["ZamieńLinkiWewnętrzneNaTekst"]{tekst,nieklasycznie,}; return tekst; end; local function JedenNawiasLinkowe(tekst) tekst=p["ZamieńLinkiZewnętrzneNaTekst"]{tekst,nieklasycznie,}; return tekst; end; local function Komentarze(tekst) tekst=p["UsuńKomentarze"](tekst); return tekst; end; local function SzablonyStylowe(tekst) tekst=p["UsuńSzablonyStylów"](tekst); return tekst; end; local function ZnakiSpecjalne(tekst) tekst=p["UsuńZnakiSpecjalne"](tekst); return tekst; end; local function Znaczniki(tekst,jakie,__FUNKCJA1,__FUNKCJA2) tekst=p["UsuńZnaczniki"](tekst,jakie,__FUNKCJA1,__FUNKCJA2); return tekst; end; local function PreProcessFrame(tekst) local frame=mw.getCurrentFrame(); frame=frame.getParent and frame:getParent() or frame; tekst=frame:preprocess(tekst); return tekst; end; </syntaxhighlight> oprócz operacji: {{Code|SzablonyStylowe(tekst)}}, {{Code|ZnakiSpecjalne(tekst)}} i {{Code|Znaczniki(tekst,jakie,__FUNKCJA1,__FUNKCJA2)}}, gdy {{Code|nagłówek}} jest pusty lub niepodany, wtedy zwracany jest tekst, i kolejno te funkcje, a w przypadku przeciwnej wartości tej zmiennej jest zwracany tylko tekst. Perzy okazji można przez niepustej zmiennej {{Code|preproces}} znaki specjalne znaczników są zamieniane na szablony: {{s|Mniejszy}} i {{s|Większy}}, przy pomocy funkcji: {{Code|tekst{{=}}p.ZnakiSpecjalneAnulowaniaIchZnaczeniaTagowegoMediaWiki(tekst)}}, a następnie rozwijany jest funkcją {{Code|PreProcessFrame(tekst)}} przy wyłączeniu znaczenia znaczniki mechanizmu MediaWiki, nie HTML (bo są to dwie różne sprawy), ta operacja kjest robiona przed operacją przekształcania zmiennej wikikodu. Gdy {{Code|nieklasycznie}} przyjmuje wartość niepustą, wtedy moznaa zakodować tekst wikikodu, przy użyciu niepustej wartości {{Code|kodowanie}}, a przy innej wikikod powinien już być zakodowany na samym wyjściu. Gdy mamy obiekty w rozwijaniu przy pomocy {{Code|{{m|Szablonowe}}}}, można wygenerować nową zawartość szablonu, sprawdzić, czy ona się zgadza instrukcją: <syntaxhighlight lang="lua"> if(((not funkcja1) or (szablon))and((not funkcja2) or funkcja2(szablon,obiekt,kod)))then </syntaxhighlight> i dalej go przekształcać, przy zmiennej {{Code|nagłówek}} nie pustej, pozostawiając kody atrybutów, znaczników, i obiektów określonych normą: <syntaxhighlight lang="lua"> if((obiekt=="NOWIKI")or(obiekt=="MATH")or(obiekt=="ŹRÓDŁO")or(obiekt=="GALERIA")or(obiekt=="MAPAOBRAZU")or(obiekt=="PUDEŁKOWEJŚCIA")or(obiekt=="QUIZ"))then </syntaxhighlight> Po uzyskaniu tak rozwiniętego kody, przy zmiennej {{Code|nagłówek}} niepustej, wtedy zostaje nie zostaną wywołane funkcje: {{Code|tekst{{=}}SzablonyStylowe(tekst)}} i {{Code|tekst{{=}}ZnakiSpecjalne(tekst)}}, ale one zostają zwrócone po kolei wraz z wikikodem w pierwszej kolejności i dalej kolejno te funkcje. A gdy jednak ta pierwsza zmienna w tej linijce zostanie pusta lub niepodana, wtedy zwracany jest sam czysty rozwinięty i oczyszczony tekst. W module {{Code|{{ld2|StronicowyParser/GłównaFunkcjaZbieraniaDanychStron}}}}, wywoływana jest funkcja: <syntaxhighlight lang="lua"> local naglowek,Znaczniki,SzablonyStylowe,ZnakiSpecjalne=specjalne_modul["WydzielZwykłyTekst"]( { -- Wikitekst z elementami mechanizmu MediaWiki tekst=naglowek, -- Zwróć test i funkcje, które muszą coś zrobić; ["nagłówek"]=true, -- Rób operacje według drugiego sposobu rozwijania z dwóch dostępnych; nieklasycznie=true, -- Ma nie kodować wikitekstu kodowanie=false, -- Gotowa tablica kodowania wikitekstu tekst; ["tablica kodowania"]=tablica_analizy_obiektow_strony_dany_modul, }, -- Funkcja: funkcja1; function(szablon,obiekt,kod) local szablon,wynik=SzablonyWywolywane(szablon,obiekt,kod); return szablon,wynik; end, --- Funkcja: funkcja2; function(szablon,obiekt,kod) return czy_indeksowanie; end); </syntaxhighlight> która oczyszcza tekst potrzebnymi funkcjami, zwracając również funkcje,które muszą dokonać dalszej roboty, jeżeli będzie ona potrzebna w jakieś formie. == {{Code|p["WydzielLiczbę"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, i wydziela tekst z elementów mechanizmu wikikodu, w tym linki wewnętrzne, zewnętrzne, i inne. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["WydzielLiczbę"] = function(frame)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} lub {{Code|tekst}} - parametr opisujący wikikod jako zwykły tekst. Parametry w jego wykazie są podanej w takiej odwrotnej kolejności, niż w jakiej są one sprawdzane, czy ta zmienna istnieje, czyli np. jeżeli zmienna {{Code|tekst}} istnieje, to nie jest wtedy sprawdzane {{Code|1}}, w przeciwnym wypadku jest sprawdzane jego istnienie i ściągana jego zawartość. Funkcja do swojego działania wykorzystuje funkcję {{Code|{{sr|#p["WydzielZwykłyTekst"](frame)|p=Specjalne}}}}, i wydziela z niej liczbę i ją zwraca w postaci przekłształconej do liczby przy pomocy funkcji {{Code|tunumber}}, a jeżeli takiej liczby nie znalazł, to zwraca {{Code|nil}}. Przykłady użycia: <syntaxhighlight lang="lua"> local specjalne_modul=require("Module:Specjalne"); local tekst="[[:en:w:Wikipedia:Strona projektu wikipdii|Link +547 567 567]]"; -- Równoważnie: local liczba=specjalne_modul["WydzielLiczbę"]{tekst=tekst,}; -- Równoważnie: local liczba=specjalne_modul["WydzielLiczbę"]{args={tekst=tekst,},}; local liczba=specjalne_modul["WydzielLiczbę"](tekst); </syntaxhighlight> Funkcja zwraca liczbę po usunięciu odstępów w postaci zmiennej typu {{Code|number}}: <syntaxhighlight lang="lua"> local liczba=547567567; </syntaxhighlight> Fukcja jest wykorzystywana w funkcji: {{Code|{{sr|#p["Forma wyrażenia po liczbie"](frame)|p=Techniczne}}}}, a więc i jednocześnie w szablonie: {{s|Forma wyrażenia po liczbie}} i jego pokrewnych z niej wynikających. == {{Code|p["PrzetwórzNagłówek"](...)}} == Szablon sprawdza zawartość tekstu wikikodu, i wydziela z niego adres linku wewnętrznego i nazwę linku (nagłówka). Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["PrzetwórzNagłówek"]=function(adres,czy_naglowek_linku,czy_nie_rozwin_adres)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - czy ma liczyć tylko adres (wartość typu {{Strong|string}}) * {{Code|czy_naglowek_linku}} - czy ma liczyc nagłówek linku (wartość typu {{Strong|boolean}}), * {{Code|czy_nie_rozwin_adres}} - czy adres linku ma rozwijać funkcją {{Code|frame:preprocess}} (wartość typu {{Strong|boolean}}). Funkcja używa do swojego działania {{Code|{{sr|#p["WydzielZwykłyTekst"](frame)|p=Specjalne}}}} do wydzielania tekstu, zwraca tutaj przetworzony tekst wydzielony z elementów mechanizmu {{Strong|MediaWiki}}, oprócz zastosowania funkcji: {{Code|Znaczniki}}, {{Code|SzablonyStylowe}} i {{Code|ZnakiSpecjalne}}, które zostaną zastosowane do zwracanej pierwszej wartości podczas liczenia adresu, a podczas liczenia nagłówka tylko funkcja {{Code|Znaczniki}} zostanie zastosowana, ale tylko dla niektórych elementów, a nie dla wszystkich, a za to dla pierwszej, wręcz przeciwnie, dla wszystkich. Przykład: <syntaxhighlight lang="lua"> local adres,naglowek=specjalne_modul["PrzetwórzNagłówek"](adres,true,false); </syntaxhighlight> Funkcja liczy adres linku i nazwę linku (naglowka) linku, które są zwracane kolejno w postaci dwóch zwracanych zmiennych, mając jedynie nieprzetworzony adres w wikikodzie, z prawdopodobnie z elementami mechanizmu MediaWiki, co po zwróceniu dwóch zmiennych otrzymujemy oczyszczony z elementów mechanizmu {{Strong|MediaWiki}} i {{Strong|HTML}}, tak jest w przypadku zmiennej {{Code|adres}}, a dla {{Code|naglowek}} jedynie zawiera niektóre elementy znaczników {{Strong|HTML}}, elementy takie jak: {{Tag|ol}}, {{Code|ul}} i {{Code|li}}, w tej funkcji są usuwane z nagłówka elementu nazwy linku, a inne znaczniki, te które są również znacznikkami {{Strong|HTML}} w mechanizmie nie są usuwane, w tym również znacznik {{Tag|pre}}, który jest jednocześnie znacznikiem {{Strong|HTML}} i znacznikiem mechanizmu {{Strong|MediaWiki}}. == {{Code|p["OdstępyZmiennychNumerowanychSzablonu"](frame)}} == Szablon sprawdza zawartość tekstu wikikodu, i wydziela domyślnie prawe odstępy od czarnych znaków wikikodu, w przeciwnym wypadku po podaniu pewnej zmiennej niepustej lewą. Funkcja używa funkcji do zbierania parametrów opisany w punkcie: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["OdstępyZmiennychNumerowanychSzablonu"]=function(frame)...end; </syntaxhighlight> Parametry ramki funkcji: * {{Code|1}} - zawartość tekstu z wikikodem * {{Code|lewy}} - czy ma wydzielać lewe odstępy w tekście {{Code|1}}, jeśli niepsuta, w przeciwnym wypadku prawą. Zwykłe szablony mają takę funkcję, że trimują zawartość zmiennej nienazwanej {{Code|1}}, jeżeli ją wsadzono do szablonu do zmiennej nazwanej, a więc wtedy jest konieczne używanie tejże funkcji w wikikodzie w szablonie, aby napisać jego lewe i prawe odstępy. To uwzględnia poniższy przykład: {{ŹródłoKodu|język=mediawiki|{{LuaSubst|{{ns:Template}}:L|inkludowana=tak}}}} Jest to kod przykładowego szablonu przekopiowany z: {{s|l}}, gdzie użycie tejże funkcji jest jednak konieczne. Funkcja kolejno w wywołaniach wydziela lewe a potem prawe odstępy zmiennej {{Code|1}}, przy użyciu parametru {{Parametr|wyspecjalizowana|tak}}. Funkcja produkuje link wewnętrzny za pomocą szablonu {{s|Link wewnętrzny}}, która ucina odstępy na początku i końcu zmiennej {{Code|s}}, a niekoniecznie {{Code|1}}. Przed i po linku są ustawiane odstępy, aby zachować historie produkowanych szablonów, jeżeli przeprowadzamy wizualizację danego szablonu. Szablonem do oglądania jego jest: {{s|PreWikikod}}, w którym jest ukryta funkcja {{Code|{{m|Techniczne|Wikikod}}}}. W tym szablonie jest ukryty inny szablon, a mianowicie {{s|Pre}}, dlatego jest zachowana historia, co do odstępów, i nowych linii, wikikodu. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> p2kwk8qyhj72m71l2xn5tmuewltqme8 4 63462 541343 541302 2026-04-30T06:52:16Z Persino 2851 /* {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} */ 541343 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ę dziesiętnymi, szesnastkowymi i literowymi kodami {{Strong|HTML}} i zamieniania ich na odpowiednie znaki, zamieniania znaków na ich kody dziesiętne, 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 łączenie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p.KodowanieOmijanieFunkcyjne(html,...)}} == Funkcja wywołuje funkcję modułu {{Code|{{ld2|Szeregi}}}} zwaną {{Code|{{sr|#p.SzeregiOmijanieFunkcyjne(tekst,...)|p=Szeregi}}}}. Domyślnym wzorem jest {{Code|<nowiki>&([^&;%s]+);</nowiki>}}, ale można go zmienić na inny. Drugą funkcją podawaną do tej funkcji jest domyślnym obiektem funkcyjnym anonimowym, który nie podaje się do funkcji w nagłówku: <syntaxhighlight lang="lua"> function(kod) return "&"..kod..";"; end </syntaxhighlight> Gdzie {{Code|kod}} jest elementem przechwytywanym kodu {{Strong|HTML}}, który jest określony poprzez nawiasy okrągłe we wzorze podawanym jako argument lub jeśli jest on równy {{Code|nil}}, wtedy we wzorze domyślnym. Funkcja służy do omijania wszystkich kodów {{Strong|HTML}} lub tylko niektórych i robienia na nich operacji za pomocą funkcji podawanej jako ostatni parametr. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.KodowanieOmijanieFunkcyjne(html,normalnie,wzor,funkcja)...end; </syntaxhighlight> Parametry: * {{Code|html}} - ciąg do przetworzenia, w częściach bez parametrów omijanych, * {{Code|normalnie}} - czy ma przetwarzać tekst pomijając, w przeciwnym wypadku tak nie robi, * {{Code|wzor}} - wzór do elementów pomijanych, wzór może mieć tylko jeden element przechwytywany, * {{Code|funkcja}} - funkcja robiąca operacje na przetworzonych subciągach bez elementów pomijanych. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest tekst wywołania: \"&#35;\""; local tekst2=html_modul.KodowanieOmijanieFunkcyjne(tekst,true,"&(#35);",function(tekst) return mw.uri.encode(tekst); end); </syntaxhighlight> Wynik jest: <syntaxhighlight lang="lua"> local tekst2="Oto+jest+tekst+wywo%C5%82ania%3A+%22&#35;%22"; </syntaxhighlight> == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody dziesiętne {{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 się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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 się tekst do zamiany kodów {{Strong|HTML}}, dziesiętnych i szesnastkowych, na znaki. 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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 tekście (w zawartości pomiędzy tagami tagu {{Tag|nowiki}}, by potem je tam umieścić, by pierwotna zawartość równała się tekstowi wyświetlanemu (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}})), wikikodu na kody dziesiętne {{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 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 się tekst do zamiany znaków, z zestawu znaków specjalnych wskazanych w funkcji, występujących w tagach języka '''HTML''' do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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 się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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,normalnie)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}. Parametry ramki funkcji tablicy transportu: * {{Code|html}} - zmienna, pod którym wyszukuje się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego kodu {{Strong|HTML}}, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}, jeżeli jej wartość odpowiada wartości logicznej {{Code|false}}, wtedy liczy się jej wersja parametrowa funkcji. 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|html}}. 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 samym początku, to jest określane 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 się tekst do zamiany z podanego zestawu znaków pierwszych znaków listy, mechanizmu {{Strong|MediaWiki}}, do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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 zamienia znaki {{Code|<nowiki>=%?&</nowiki>}} na kody dziesiętne {{Strong|HTML}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Funkcja potrafi opcjonalnie omijać kody {{Strong|HTML}}, w zależności od podanego drugiego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame,normalnie)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}. Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego kodu {{Strong|HTML}}, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}, jeżeli jej wartość odpowiada wartości logicznej {{Code|false}}, wtedy liczy się jej wersja parametrowa funkcji. 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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 się tekst do zamiany znaków przypisania {{Code|{{=}}}} do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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 dziesiętne {{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 się tekst do zamiany ze znaku dwukropka do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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 dziesiętny {{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 dziesiętny {{Strong|HTML}}, * {{Code|2}} - czy znak {{Code|{{Nowiki|&}}}} ma być zamieniany na {{Code|{{Nowiki|&amp;}}}}, a znak {{Code|<nowiki>#</nowiki>}} na {{Code|{{Nowiki|&num;}}}}. 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}}. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}. 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 === Zamienia ściśle określone znaki (zestaw kodów znajduje się na stronie: {{Code|{{ls2|KodyHTMLZnakówWikiCiągu/opis}}}}) na kody dziesiętne {{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["KodyHTMLZnakówWikiCiągu"](frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|1}} - ciąg, pod którym są możliwe ściśle określone znaki są zamieniane na kod {{Strong|HTML}}, ciąg ten jest ze znakami wiki w UTF8, * {{Code|2}} - czy znak {{Code|{{Nowiki|&}}}} ma być zamieniany na {{Code|{{Nowiki|&amp;}}}} i {{Code|<nowiki>#</nowiki>}} na {{Code|{{Nowiki|&num;}}}}. 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}}. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="k{{s"; -- Równoważne: local tekst2=html_modul["KodyHTMLZnakówWikiCiągu"]{[1]=tekst,}; -- Równoważne: local tekst2=html_modul["KodyHTMLZnakówWikiCiągu"]{args={[1]=tekst,},}; local tekst2=html_modul["KodyHTMLZnakówWikiCiągu"](znak); -- Równoważne: local tekst3=html_modul["KodyHTMLZnakówWikiCiągu"]{[1]=tekst,[1]="tak",}; local tekst3=html_modul["KodyHTMLZnakówWikiCiągu"]{args={[1]=tekst,[2]="tak",},}; </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="k&#123;&#123;s"; local tekst3="k&amp;&num;123;&amp;&num;123;s"; </syntaxhighlight> Szablonowo taką zamianę możemy napisać: * {{Code|{{s|KodyHTMLZnakówWikiCiągu|k{{s|((}}s}}}} → {{Tt|{{KodyHTMLZnakówWikiCiągu|k{{((}}s}}}} * {{Code|{{s|Nowiki|{{s|KodyHTMLZnakówWikiCiągu|k{{s|((}}s}}}}}} → {{Tt|{{Nowiki|{{KodyHTMLZnakówWikiCiągu|k{{((}}s}}}}}} * {{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}}}}}} Równie dobrze możemy napisać takie wywołania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="mediawiki"> <!-- Wyświetla wynik: "k&#123;&#123;s"; --> {{#invoke:Html|KodyHTMLZnakówWikiCiągu|k{{((}}s|wyspecjalizowana=tak}} <!-- Wyświetla wynik: "k&amp;&num;123;&amp;&num;123;s"; --> {{#invoke:Html|KodyHTMLZnakówWikiCiągu|k{{((}}s|tak|wyspecjalizowana=tak}} </syntaxhighlight> == {{Code|p.EncodeId(...)}} == Funkcja służy do opcjonalnego dekodowania ciągów znakowych według {{Code|{{sr|#p.DecodeHtml(...)|p=Html}}}}, i cały ciąg od specjalnych znaków jest transformowany przez funkcję {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeId(id,bez_transformacji)...end; </syntaxhighlight> Parametry nieramkowe normalne funkcji: * {{Code|id}} - ciąg do przeinaczenia, * {{Code|bez_transformacji}} - gdy nie {{Code|false}} lub {{Code|nil}}, funkcja nie transformuje na podstawie: {{Code|{{sr|#p.DecodeHtml(...)|p=Html}}}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local id="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; local id2=html_modul.EncodeId(id,false); </syntaxhighlight> Wynikiem tego: <syntaxhighlight lang="lua"> local id2="https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link wewnętrzny&#38;action&#61;edit&#35;Obsługa"; </syntaxhighlight> Gdy: {{Code|bez_transformacji{{=}}true}}, funkcja działa jak: {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}, ale wtedy {{Code|frame{{=}}id}}, a przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local id="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; local id2=html_modul.EncodeId(id,true); </syntaxhighlight> Wynikiem działania jest wartość ostatniej zmiennej: <syntaxhighlight lang="lua"> local id2="https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link_wewn%C4%99trzny&#38;action&#61;edit&#35;Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == Usuwa z tekstu znak numer {{Code|8206}} zestawu {{lpg|Unicode}}, który można napisać, jeśli jest widoczny na ekranie komputera {{Code|&#8206;}} (znak {{Code|{{Nowiki|&#8206;}}}}). Ten znak oczywiście Unicode jest w grupie zwanej invisible Unicode characters i służy do ustawiania kierunku tekstu lewo do prawo. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)...end; </syntaxhighlight> Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tutaj jest zakodowany znak HTML, o kodzie dziesiętnym "&#8206;", składający się z trzech bajtów: "&#226;", "&#128;" i "&#142;"; local tekst="Oto jest znak: &#8206;."; -- Zamiana tego kodu na znak; tekst=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); -- Tekst bez tego znaku, bo on został w tym wywołaniu całkowicie usunięty; tekst=html_modul.UsuwanieSpecjalnychNieschematycznychSymboli(tekst); </syntaxhighlight> Wynikiem tego kodu jest wartość ukryta pod zmienną: <syntaxhighlight lang="lua"> local tekst="Oto jest znak: ."; </syntaxhighlight> == {{Code|p.EncodeWiki(...)}} == Funkcja transformuje kody {{Strong|HTML}} do znaku przy pomocy funkcji {{Code|{{sr|#p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)|p=Html}}}}, usuwa nieschematyczne znaki o kodzie {{Code|{{Nowiki|&#8206;}}}} dzięki funkcji: {{Code|{{sr|#p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)|p=Html}}}}, następnie opcjonalnie usuwa znaki będące odstępami lub dolnymi myślnikami z początku i końca tekstu, i zamienia wewnątrz znaki kolejne odstępów lub dolnych myślników na jeden dolny myślnik na podstawie {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, dalej zaraz funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.text.encode|n=mw.text.encode}}}} koduje tekst, tą funkcją {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeWiki(parametr,czy_nie_odstepy)...end; </syntaxhighlight> Parametry: * {{Code|parametr}} - tekst, który chcemy zakodować, * {{Code|czy_nie_odstepy}} - czy nie ma na tekst podziałać funkcją {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local parametr="__Oto jest znak: \"&#8206;\" i inne_znaki_w_URL: \"https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link wewnętrzny&#38;action&#61;edit&#35;Obsługa;\"__"; local parametr2=html_modul.EncodeWiki(parametr,false); local parametr3=html_modul.EncodeWiki(parametr,true); </syntaxhighlight> Wynikiem działania tej funkcji jest parametr {{Code|parametr2}} i {{Code|parametr3}}, którego wartości: <syntaxhighlight lang="lua"> local parametr2="Oto_jest_znak:_&quot;&quot;_i_inne_znaki_w_URL:_&quot;https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewnętrzny&amp;action=edit#Obsługa;&quot;"; local parametr3="__Oto jest znak: &quot;&quot; i inne_znaki_w_URL: &quot;https://pl.wikibooks.org/w/index.php?title=Szablon:Link wewnętrzny&amp;action=edit#Obsługa;&quot;__"; </syntaxhighlight> == {{Code|p.DecodeWiki(...)}} == Funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.text.decode|n=mw.text.decode}}}} dekoduje tekst, tą funkcją {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Następnie usuwa nieschematyczne symbole: {{Code|{{Nowiki|&#8206;}}}}, dzięki funkcji: {{Code|{{sr|#p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)|p=Html}}}}, następnie działa opcjonalnie funkcją, która usuwa znaki będące odstępami lub dolnymi myślnikami z początku i końca tekstu oraz zamieniając wewnątrz znaki kolejne odstępów lub dolnych myślników na jedną dolną spacją na podstawie {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeWiki(parametr,czy_nie_odstepy)...end; </syntaxhighlight> Parametry: * {{Code|parametr}} - tekst, który chcemy odkodować, * {{Code|czy_nie_odstepy}} - czy nie ma na tekst podziałać funkcją {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local parametr="__Oto jest znak: &quot;&#8206;&quot; i inne_znaki_w_URL: &quot;https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link wewnętrzny&#38;action&#61;edit&#35;Obsługa;&quot;__"; local parametr2=html_modul.DecodeWiki(parametr,false); local parametr3=html_modul.DecodeWiki(parametr,true); </syntaxhighlight> Wynikiem działania tej funkcji jest parametr {{Code|parametr2}} i {{Code|parametr3}}, którego wartość: <syntaxhighlight lang="lua"> local parametr2="Oto jest znak: \"\" i inne znaki w URL: \"https://pl.wikibooks.org/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa;\""; local parametr3="__Oto jest znak: \"\" i inne_znaki_w_URL: \"https://pl.wikibooks.org/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa;\"__"; </syntaxhighlight> == {{Code|p.IsEncodedHtml(...)}} == Funkcja sprawdza, czy można uznać, że funkcja jest zakodowana, tzn. dalej nie warto jej kodować przy pomocy funkcji: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}, czy dekodować, bo już można uznać ją za odkodowaną, czyli nie trzeba stosować funkcji: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}. Funkcja zwraca wartość {{Code|true}}, jak można uznać tekst za zakodowany i {{Code|false}}, gdy jest niezakodowana. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IsEncodedHtml(parametr,encode,encode_real)..end; </syntaxhighlight> Parametry funkcji: * {{Code|parametr}} - parametr do sprawdzenia - wymagany, * {{Code|encode}} - gdy jest sprawdzana tylko obecność znaku {{Code|%}}, * {{Code|encode_real}} - gdy jest sprawdzana, nie tylko obecność znaku {{Code|%}}, też czy {{Code|parametr}} jest ciągiem podporządkowanym wyrażeniu regularnemu {{Code|<nowiki>^[%w%p%s]*$</nowiki>}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Pierwszy przykład: local parametr1="abc?edit=action"; -- Wartość zmiennej obliczona jest: czy_tak1=true, czyli parametr1 można uznać za zakodowany; local czy_tak1=html_modul.IsEncodedHtml(parametr1,true,false); -- Drugi przykład: local parametr2="a%YTbc?edit=action;"; -- Wartość zmiennej obliczona jest: czy_tak2=false; czyli parametr2można uznać, że nie jest zakodowany; local czy_tak2=html_modul.IsEncodedHtml(parametr2,true,false); </syntaxhighlight> == {{Code|p.EncodeHtml(...)}} == Funkcja sprawdza, czy podany parametr do transformacji uznać za zakodowany, jeżeli za taki zostanie uznany, wtedy zostanie, to on zostanie potraktowany funkcją {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}, a jeżeli nie to zostanie wywołana funkcja: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}} (z parametrem "WIKI"). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeHtml(parametr,encode,encode_real,czy_nie_odstepy)...end; </syntaxhighlight> Parametry funkcji: * {{Code|parametr}} - parametr do transformacji kodowania, * {{Code|encode}} i {{Code|encode_real}} - te parametry to samo oznaczają, co w funkcji: {{Code|{{sr|#p.IsEncodedHtml(...)|p=Html}}}}, * {{Code|czy_nie_odstepy}} - to samo oznacza, co w funkcji {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}. {{Hr}} Przykłady pierwszy - podany tekst już zakodowany: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst do zakodowania; local parametr="abc___&#63;action&#61;edit&#38;section&#61;21&#35;nagłówek"; -- Tekst zostanie uznany za zakodowany, sprawdzane, czy on ma znaki "%", czyli on tego nie posiada; local parametr2=html_modul.EncodeHtml(parametr,true,false,false); </syntaxhighlight> Wynik zmiennej {{Code|parametr2}} jest ukryty pod jego wartością: <syntaxhighlight lang="lua"> -- Widzimy, że podwojone myślniki dolne zostały zamienione na pojedyncze, kody HTML zostały zamienione na znaki, a znak "&#38;", czyli "&" został zamieniony na "&amp;"; local parametr2="abc_?action=edit&amp;section=21#nagłówek"; </syntaxhighlight> {{Hr}} Przykłady drugi - podany tekst jeszcze nie zakodowany: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst do zakodowania; local parametr="a%YTbc___?action=edit;"; -- Tekst zostanie uznany za niezakodowany, czy on ma znaki "%", czyli on to posiada; local parametr2=html_modul.EncodeHtml(parametr,true,false,false); </syntaxhighlight> Wynik zmiennej {{Code|parametr2}} jest ukryty pod jego wartością: <syntaxhighlight lang="lua"> -- Widzimy, że znak "%" został zakodowany funkcją mw.uri.encode, podobnie tą funkcją zostały zakodowane: "?" i "="; local parametr2="a%25YTbc___%3Faction%3Dedit;"; </syntaxhighlight> == {{Code|p.DecodeHtml(...)}} == Funkcja sprawdza, czy {{Code|parametr}}, czy można uznać za zakodowany, a jeżeli można, to on zostanie w zależnosci od parametru {{Code|spacje}}, to odpowiednio zostanie wywołana {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a następnie w zależności od parametru (opis w parametrach) zostanie wywołana odpowiednia funkcja odkoduwująca lub kodująca {{Code|wiki}}. Jeżeli ciąg rzeczywiście jest uznany za niezakodowany jest podobnie odpowiednio z tylko z wywołaniami funkcji {{Code|wiki}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeHtml(parametr,spacje,encode,encode_real,czy_nie_odstepy)...end; </syntaxhighlight> Parametry:z * {{Code|parametr}} - parametr do odkodowania, * {{Code|spacje}} - gdy parametr odpowiada {{Code|true}} używa funkcji {{Code|{{sr|#p.DecodeWiki(...)|p=Html}}}}, w przeciwnym wypadku: {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}, ale wpierw musi zostać wywołana funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}} w przypadku, gdy ciąg zostanie uznany za zakodowany, jak to robi funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}, * {{Code|encode}} i {{Code|encode_real}} - te parametry są używane przez funkcje {{Code|{{sr|#p.IsEncodedHtml(...)|p=Html}}}}, * {{Code|czy_nie_odstepy}} - gdy ciąg został uznany za niezakodowany, wtedy to jest drugi parametr funkcji: {{Code|{{sr|#p.DecodeWiki(...)|p=Html}}}} lub {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Parametr zawiera znaki zakodowane funkcją mw.uri.encode i kody HTML znaków; local parametr="a%25YTbc___%3Faction%3Dedit&#38;section&#61;23;"; local parametr2=html_modul.DecodeHtml(parametr,true); </syntaxhighlight> Wynik funkcji jest ukryty pod adresem: <syntaxhighlight lang="lua"> -- Funkcja została uznana za zakodowaną i odkodowano ją funkcją mw.uri.decode, dalej dwa dolne myślniki zostały zamienione na jedną spację, a kody HTML zostały zamienione na odpowiednie znaki; local parametr2="a%YTbc ?action=edit&section=23;"; </syntaxhighlight> == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == Szuka atrybutów w cudzysłowach i w nich elementy {{Code|<nowiki><>&</nowiki>}} zamienia na kody dziesiętne {{Strong|HTML}}, a także znaki lewego ukośnika {{Code|<nowiki>\</nowiki>}} też na to. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)...end; </syntaxhighlight> Parametry: * {{Code|znacznik}} - atrybut do przetwarzania, aby w nim zamienić niektóre znaki, które przeszkadzają w analizie na kody, o odpowiednim formacie, {{Strong|HTML}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"Znaki<>\\\"\">To jest zawartość</span>"; local tekst2=html_modul.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(tekst); </syntaxhighlight> Wartość tej zmiennej jest ukryta pod {{Code|tekst2}}: <syntaxhighlight lang="lua"> -- Widzimy, że został sam jeden atrybut ze znakami HTML wewnątrz; local tekst2="<span id=\"Znaki&lt;&gt;&#92;&#34;\">To jest zawartość</span>"; </syntaxhighlight> == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == Zamienia kody {{Strong|HTML}}, tzn.: {{Code|{{Nowiki|&lt;}}}}, {{Code|{{Nowiki|&gt;}}}} i {{Code|{{Nowiki|&amp;}}}}, na odpowiednio znaki, a także elementy {{Code|{{Nowiki|&#92;&#34;}}}} na {{Code|<nowiki>\"</nowiki>}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)...end; </syntaxhighlight> Parametry: * {{Code|value}} - parametr do transformacji niektórych kodów {{Strong|HTML}} na znaki. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="&lt;a href=\"/wiki/Strona?tytan1=1&amp;tytan2=2\" id=\"Strona:&#92;&#34;nazwa&#92;&#34;\"&gt;Zawartość znacznika&lt;/a&gt;"; local tekst2=html_modul.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(tekst); </syntaxhighlight> Otrzymana zawartość jest pod {{Code|tekst2}}: <syntaxhighlight lang="lua"> -- Widzimy, że kody odpowiednie HTML, tzn.: "&lt;", "&gt;" i "&amp;" zostały zamienione na odpowwiednie znaki; local tekst2="<a href=\"/wiki/Strona?tytan1=1&tytan2=2\" id=\"Strona:\\\"nazwa\\\"\">Zawartość znacznika</a>"; </syntaxhighlight> == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == Funkcja wydziela nagłówek z adresu strony, funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NagłówekStronyAdresu"]=function(frame,czy_nie_dolne_myslniki,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_nie_dolne_myslniki}} - gdy {{Code|true}}, jeśli w nagłówku nie ma prawa być dolnych myślników, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Funkcja usuwa zbędne odstępy i dolne myślniki na końcach nagłówka, i powtarzające się znaki będące odstępami lub dolnymi myślnikami są zastępowane przez jedną spację, gdy {{Code|czy_nie_dolne_myslniki}} równa jest wartości odpowiadającej {{Code|true}}, w przeciwnym wypadku zamieniana jest ona na jeden dolny myślnik. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_nie_dolne_myslniki}} (parametr funkcji), {{Code|2}} lub {{Code|z nie dolnymi z myślnikami}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local naglowek=html_modul["NagłówekStronyAdresu"](strona,true,tabela_nazw_adresu); local naglowek=html_modul["NagłówekStronyAdresu"]({strona=strona,["z nie dolnymi z myślnikami"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony, nagłówek usuwając z niego myślniki dolne i trimując zawartość; local naglowek="Nagłówek strony"; </syntaxhighlight> == {{Code|p["ParametryStronyAdresu"](frame,...)}} == Funkcja wydziela parametry z adresu strony, funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ParametryStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma suwać zbędne odstępy i dolne myślniki z parametrów adresu, wydzieloną z pełnego adresu strony, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local parametry=html_modul["ParametryStronyAdresu"](strona,true,tabela_nazw_adresu); local parametry=html_modul["ParametryStronyAdresu"]({strona=strona,["czy naprawiać"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony parametry, usuwając z niego zbędne odstępy i myślniki dolne; local parametry="action=edit&section=2"; </syntaxhighlight> == {{Code|p["NazwaStronyAdresu"](frame,...)}} == Funkcja wydziela nazwę strony z adresu strony, funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwaStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma suwać zbędne odstępy i dolne myślniki z adresu strony, bez parametrów i nagłówka, wydzieloną z pełnego adresu strony, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local parametry=html_modul["NazwaStronyAdresu"](strona,true,tabela_nazw_adresu); local nazwa_strony=html_modul["NazwaStronyAdresu"]({strona=strona,["czy naprawiać"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony nazwę strony adresu, usuwając z niego zbędne odstępy i myślniki dolne; local nazwa_strony="https://pl.wikibooks.org/wiki/Strona_główna"; </syntaxhighlight> == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == Funkcja wydziela nazwę strony z parametrów adresu strony. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["NazwaStronyZParametrówStronyAdresu"]=function(frame,czy_naprawiaj)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma suwać zbędne odstępy i dolne myślniki z parametrów strony adresu, i czy zamieniać je na pojedyncze spacje wewnątrz nazwy artykułu wydzieloną z parametrów strony. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}} lub {{Code|parametry}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}} lub {{Code|parametry}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="title=Strona ___ główna & action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; -- Równoważne: local parametry=html_modul["NazwaStronyZParametrówStronyAdresu"](strona,true); local nazwa_strony=html_modul["NazwaStronyZParametrówStronyAdresu"]({parametry=strona,["czy naprawiać"]=true,},nil); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony nazwę artykułu, usuwając z niego zbędne odstępy i myślniki dolne; local nazwa_strony="Strona główna"; </syntaxhighlight> == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == Funkcja poprawia pełny adres strony, rozdzielając ją na części, a później łącząc. Funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma naprawiać pełny adres strony, działając w sposób specyficzny w zależności od funkcji, która operuje na jej częściach, wykorzystując funkcje, które są napisane w linii zaraz poniżej, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local parametry=html_modul["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](strona,true,tabela_nazw_adresu); local adres=html_modul["PoprawAdresNagłówkaOrazParametrówStronyAdresu"]({strona=strona,["czy naprawiać"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość pełnego adresu strony poprawiona jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z pełnego adresu strony adres, parametry i nagłówek, naprawione i złączone ze sobą w pełny poprawiony adres; local adres="https://pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; </syntaxhighlight> == {{Code|p.URLStrona(frame)}} == Funkcja z adresu '''URL''' wydziela nazwę serwera i nazwę strony. On nie może zawierać w sobie protokołu, tylko musi zaczynać od {{Code|<nowiki>//</nowiki>}}. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.URLStrona(frame)...end; </syntaxhighlight> Parametry ramki: * {{Code|1}} lub {{Code|url}} - adres strony, * {{Code|2}} lub {{Code|ukośnik}} - czy do nazwy strony ma wliczać ukośnik. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"): local url="//pl.wikibooks.org/wiki/Strona_artykułu"; local serwer,nazwa=html_modul.URLStrona{url=url,["ukośnik"]=true,}; </syntaxhighlight> Wartości zmiennych kryją się pod: <syntaxhighlight lang="lua"> -- Widzimy, że nazwa serwera jest bez prawych ukośników; local serwer="pl.wikibooks.org"; -- Nazwa strony zaczyna się bez ukośnika, bo powiedzieliśmy funkcji, by nie brał prawych ukośników, które są na początku nazwy strony, bez nazwy serwera i protokołu, ale w sobie może mieć on, ale nie musi; local nazwa="wiki/Strona_artykułu"; -- Gdyby było ["ukośnik"]=false, to wtedy otrzymalibyśmy inny wynik, czyli: local nazwa="/wiki/Strona_artykułu"; </syntaxhighlight> == {{Code|p["UrlBezProtokołu"](frame)}} == Funkcja adresowi z protokołem usuwa to właśnie, a jak podamy adres „mail”, to podaje nazwę tego adresu, bez niego. Drugą zwracaną nazwą jest nazwa protokołu,a jak się nie da go wyznaczyć, to funkcja zwraca wartość {{Code|nil}}. Trzecia wartość, to numer sposoby, a jeżeli żaden sposób nie pasuje, to ta wartość jest {{Code|-1}}, a gdy adres mail {{Code|1}}, dla adresu z protokołem {{Code|2}}, a dla adresu bez protokołu {{Code|3}}. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UrlBezProtokołu"]=function(frame)...end; </syntaxhighlight> Parametry ramki: * {{Code|1}} lub {{Code|url}} - adres strony, ewentualnie z opcjonalnym protokołem. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}} lub {{Code|url}}. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local mail="użytkownik@skrzynka.org"; -- Równoważnie: local adres1,protokol1,sposob1=html_modul["UrlBezProtokołu"](mail); local adres1,protokol1,sposob1=html_modul["UrlBezProtokołu"]{url=mail,}; --- local url="https://pl.wikibooks.org/wiki/Strona"; -- Równoważnie: local adres2,protokol2,sposob2=html_modul["UrlBezProtokołu"](url); local adres2,protokol2,sposob2=html_modul["UrlBezProtokołu"]{url=url,}; --- local url="//pl.wikibooks.org/wiki/Strona"; -- Równoważnie: local adres3,protokol3,sposob3=html_modul["UrlBezProtokołu"](url); local adres3,protokol3,sposob3=html_modul["UrlBezProtokołu"]{url=url,}; --- local url="pl.wikibooks.org/wiki/Strona"; -- Równoważnie: local adres4,protokol4,sposob4=html_modul["UrlBezProtokołu"](url); local adres4,protokol4,sposob4=html_modul["UrlBezProtokołu"]{url=url,}; </syntaxhighlight> Wyniki otrzymane z powyższych przykładów są: <syntaxhighlight lang="lua"> local adres1,protokol1,sposob1="//skrzynka.org","mail",1; local adres2,protokol2,sposob2="//pl.wikibooks.org/wiki/Strona","https",2; local adres3,protokol3,sposob3="//pl.wikibooks.org/wiki/Strona",nil,3; local adres4,protokol4,sposob4="//pl.wikibooks.org/wiki/Strona",nil,-1; </syntaxhighlight> == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == Zamienia kody {{Strong|HTML}}, tzn. literowe (ogólny wzór {{Code|<nowiki>&(%a+);</nowiki>}}), dziesiętne (ogólny wzór {{Code|<nowiki>&#(%d+);</nowiki>}}) i szesnastkowe (ogólny wzór {{Code|<nowiki>&#x(%x+);</nowiki>}}) na odpowiednie znaki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeKoduHTMLZnaku(tekst)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tekst}} - tekst do zamienienia z dziesiętnymi, szesnastkowymi i literowymi kodami {{Strong|HTML}} na odpowiednie znaki. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst z kodami HTML: literowymi, dziesiętnymi i szesnastkowymi; local tekst="Oto jest link: &#x5B;&#x5B;Strona&#124;Nazwa linku&#93;&#x5D;, a w nim spacje niełamliwe&nbsp;i inne znaki: z alfabetu greckiego jak: &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;"; -- Wywołanie funkcji odkodujący kody HTML; local tekst2=html_modul.DecodeKoduHTMLZnaku(tekst); </syntaxhighlight> Otrzymany wynik jest pod zmienną: <syntaxhighlight lang="lua"> -- Widzimy, że tekst został zdekodowany ze znaków HTML; local tekst2="Oto jest link: [[Strona|Nazwa linku]], a w nim spacje niełamliwe i inne znaki: z alfabetu greckiego jak: αΑβΒγΓδΔεΕζΖηΗθΘιΙκΚλΛμΜνΝξΞοΟπΠρΡσΣτΤυΥφΦχΧψΨωΩ"; </syntaxhighlight> == {{Code|p.ZamianaEncodeTekst(tekst)}} == Adres strony dekoduje funkcją: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, następnie koduje, jeszcze więcej niż było na samym początku, według: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaEncodeTekst(tekst)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - tekst do odkodowania i zakodowania jeszcze więcej niż było na początku zakodowane. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; local tekst2=html_modul.ZamianaEncodeTekst(tekst); </syntaxhighlight> Wynikiem funkcji, co kryje się pod zmienną {{Code|tekst2}}: <syntaxhighlight lang="lua"> local tekst2="https%3A%2F%2Fpl.wikibooks.org%2Fw%2Findex.php%3Ftitle%3DSzablon%3ALink_wewn%C4%99trzny%26action%3Dedit%23Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == Funkcja wyszukuje tekst do zamiany i działa na niego funkcją: {{Code|{{sr|#p.ZamianaEncodeTekst(tekst)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst nie do końca zakodowany wydzielonego według poniższego wzoru; local tekst="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obsługa"; -- Wzór, który wydziela części do kodowania jeszcze bardziej niż były na samym początku; local wzor="[^/%?%=&:%#]+"; -- Wywołanie funkcji kodującej; local tekst2=html_modul.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor); </syntaxhighlight> Wynikiem funkcji, co kryje się pod zmienną {{Code|tekst2:}} <syntaxhighlight lang="lua"> -- Zakodowało jeszcze więcej niż na samym początku było zakodowane; local tekst2="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.StronaParametryIdentyfikacjaAdresuHtml(adres)}} == Funkcja z całkowitego adresu składający się z adresu właściwego, parametrów i nagłówka, rozdzielane jest na trzy części, z których się składa. Funkcja sprawdza, czy jakikolwiek kody {{Strong|HTML}} występują w pełnym adresie strony, jeżeli są to przedtem koduje jeszcze lepiej kody znaków {{Code|<nowiki>#</nowiki>}}, przy pomocy funkcji: {{Code|{{sr|#p.EncodeHashKoduHtmlTekstu(tekst)|p=Html}}}}, a później w kodach {{Strong|HTML}} znak {{Code|<nowiki>#</nowiki>}} jest zamieniany na kod literowy {{Strong|HTML}}, czyli: {{Code|{{Nowiki|&num;}}}}, funkcją: {{Code|{{sr|#p.EncodeTempHashKoduHtmlTekstu(tekst)|p=Html}}}} (jeżeli w adresie kody istnieją), wtedy cos powstaje w rodzaju dla kodu dziesietnego: {{Code|<nowiki>&&num;(%d+);</nowiki>}}, i szesnastkowego: {{Code|<nowiki>&&num;x(%x+);</nowiki>}} - gdzie w nich {{Code|<nowiki>#</nowiki>}} został zamieniony na {{Code|{{Nowiki|&num;}}}}, które są przedstawione według wyrażeń regularnych {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja rozdziela to na trzy części, a później odkodowuje każdą część funkcją: {{Code|{{sr|#p.DecodeTempHashKoduHtmlTekstu(tekst,...)|p=Html}}}} (jeżeli w adresie kody w ogóle istniały), i podobnie później: {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}} (jeżeli kody znaku: {{Code|<nowiki>#</nowiki>}}, były wcześniej). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.StronaParametryIdentyfikacjaAdresuHtml(adres)...end; </syntaxhighlight> Parametry: * {{Code|adres}} - adres do potrzelenia na trzy części. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="https://pl.wikibooks.org/wiki/Strona&#32;główna&num;&#x23;&#35;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; -- Adresstrony jedynie rozkładaa się na: "strona", "parametry" i "nagłówek"; local strona,parametry,naglowek=html_modul.StronaParametryIdentyfikacjaAdresuHtml(adres); </syntaxhighlight> Otrzymane wartości tych zmiennych kryją się pod adresami: <syntaxhighlight lang="lua"> local strona,parametry,naglowek="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#35;To_nie_jest nagłówek","action=edit&section=2","Nagłówek strony",3; </syntaxhighlight> Funkcja zwraca trzy wartości, tzn. adres właściwy (bez parametrów i nagłówka), parametry (używane jako dodatek do adresów przy formułowaniu formularzy) i nagłówek (który jest adresem na stronie do odpowiedniego elementu o danym atrybucie: {{Code|id}}). == {{Code|p.TworzenieAdresuHtml(strona,...)}} == Funkcja łączy, stronę, parametry i nagłówek strony, w pełną nazwę strony (adresu), dalej jest uruchamiana funkcja ddekodująca ciagi znakowe: {{Code|{{Nowiki|&amp;&num;}}}}. Funkcja wykorzystuje do dekodowania tego {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TworzenieAdresuHtml(strona,parametry,naglowek)...end; </syntaxhighlight> Parametry: * {{Code|strona}} - nromalny adres strony, bez parametrów i nagłówka, * {{Code|parametry}} - parametry strony w formacie {{Code|nazwa{{=}}wartość}} oddzielone od siebie znakiem {{Code|<nowiki>&</nowiki>}}, * {{Code|nagłówek}} - nagłówek linkujący do {{Code|id}} jakiegos elementyna stronie, Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona,parametry,naglowek,ile="https://pl.wikibooks.org/wiki/Strona&#32;główna&num;&#35;&#x23;To_nie_jest nagłówek","action=edit&section=2","Nagłówek strony",3; local adres=html_modul.TworzenieAdresuHtml(strona,parametry,naglowek); </syntaxhighlight> Otrzymany pełny pojedynczy adres strony, z normalnym adresem strony z parametrami i nagłówkiem, jest ukryta: <syntaxhighlight lang="lua"> local adres="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#35;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; </syntaxhighlight> Funkcja zwraca całkowity adres z adresem właściwym, parametrami (po {{Code|<nowiki>?</nowiki>}}, jeżeli po nim występują wartości przyrównane nazwą zmiennych {{Strong|HTML}}) i nagłówkiem (po {{Code|<nowiki>#</nowiki>}}). == {{Code|p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)}} == Pełny adres strony, bezprotokolarny (lub protokolarny, jeżeli rozdzielimy, w pierwszej funkcji anonimowej w tej nagłówku, na protokół i adres bezprotokolarny, czyli na dwie części, zrobimy operacje, a później je złączymy w nim), linków zewnętrznych lub wewnętrznych, z adresem właściwym, parametrami i nagłówkiem strony, po podziale na je trzy części funkcją {{Code|{{sr|#p.StronaParametryIdentyfikacjaAdresuHtml(adres)|p=Html}}}}, następnie na każdą z tych elementów działamy odpowiednimi funkcjami, a potem ich wyniki łączymy w pełny adres strony funkcją {{Code|{{sr|#p.TworzenieAdresuHtml(strona,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,funkcja_strona,funkcja_parametry,funkcja_naglowek)...end; </syntaxhighlight> Parametry: * {{Code|adres}} - pełny adres do przetworzenia, * {{Code|funkcja_strona}} - funkcja, którą działamy na właściwy adres strony, bez parametrów i nagłówka, * {{Code|funkcja_parametry}} - funkcja, którą działamy na parametry adresu strony, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek strony adresu. Przykład takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local function ParametryEncodeURL(a,b,c) return a..html_modul.ZamianaEncodeTekst(b).."="..html_modul.ZamianaEncodeTekst(c); end; local function OperacjeHtml(adres) adres=mw.ustring.gsub(adres,"^(%??)([^&=]*)=([^&]*)",ParametryEncodeURL); adres=mw.ustring.gsub(adres,"(&)([^&=]*)=([^&]*)",ParametryEncodeURL); return adres; end; return html_modul.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres, -- Funkcja: funkcja_strona; function(strona) strona=html_modul.ZamianaEncodeNaPodstawieWzoruTekstu(strona,"[^/]+"); return strona; end, -- Funkcja: funkcja_parametry; OperacjeHtml, -- Funkcja: funkcja_naglowek; function(naglowek) naglowek=html_modul.ZamianaEncodeTekst(naglowek); return naglowek; end ); </syntaxhighlight> == {{Code|p.ParametryEncodeURL(adres,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.ZamianaEncodeTekst(tekst)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.ParametryEncodeURL(adres,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="//pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obsługa"; local adres2=html_modul.ParametryEncodeURL(adres,true, function(strona) strona=html_modul.ZamianaEncodeNaPodstawieWzoruTekstu(strona,"[^/]+"); return strona; end, function(naglowek) naglowek=html_modul.ZamianaEncodeTekst(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="//pl.wikibooks.org/w/index.php?title=Szablon%3ALink_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}, ale przed nim wywoływana ajest funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a po nim {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryZaawansowanyEncodeURL(adres,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.ParametryZaawansowanyEncodeURL(adres,true, function(strona) strona=mw.uri.decode(strona); strona=html_modul.EncodeSpecjalneZnakiHtml(strona); strona=mw.uri.encode(strona); return strona; end, function(naglowek) naglowek=mw.uri.decode(naglowek); naglowek=html_modul.EncodeSpecjalneZnakiHtml(naglowek); naglowek=mw.uri.encode(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="Szablon%3ALink_wewn%C4%99trzny?action=edit#Obs%C5%82uga%26%2363%3B"; </syntaxhighlight> == {{Code|p.EncodeParametryHtml(parametr,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.EncodeHtml(...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeParametryHtml(parametr,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.EncodeParametryHtml(adres,true, function(strona) strona=html_modul.EncodeHtml(strona); return strona; end, function(naglowek) naglowek=html_modul.EncodeHtml(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="Szablon:Link_wewn%C4%99trzny?action=edit#Obs%C5%82uga%3F"; </syntaxhighlight> == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)|p=Html}}}}, a przed nim wywoływana jest {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a po nim jeżeli jest włączone kodowanie w zmiennej drugiej funkcji, wtedy {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZaawansowanyParametryHtml(adres,z_kodowaniem,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|z_kodowaniem}} - czy ostateczny nagłówek ma być zakodowany, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.EncodeZaawansowanyParametryHtml(adres,true,true, function(strona) strona=mw.uri.decode(strona); strona=html_modul.EncodePodstawoweHtmlTekstu(strona); strona=mw.uri.encode(strona); return strona; end, function(naglowek) naglowek=mw.uri.decode(naglowek); naglowek=html_modul.EncodePodstawoweHtmlTekstu(naglowek); naglowek=mw.uri.encode(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="Szablon%3ALink_wewn%C4%99trzny?action=edit#Obs%C5%82uga%26%2363%3B"; </syntaxhighlight> == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == Funkcja koduje kod {{Strong|HTML}} znaku {{Code|<nowiki>#</nowiki>}}, czyli {{Code|{{Nowiki|&num;}}}}, {{Code|{{Nowiki|&#35;}}}} i {{Code|{{Nowiki|&#x23;}}}}. Te wszystkie kody funkcja zamienia je z każdnych na kod: {{Code|{{Nowiki|&amp;num;}}}}. Funkcja zwraca przetworzony tekst, ze zmienną {{Code|ile}} mówiącej ile jest możliwych kodów na stronie, także z {{Code|ile2}} wskazującej, ile jest kodów na stronie rozwazanego znaku. Funkcja używana, gdy nie chcemy, by dodatkowe znaki {{Code|<nowiki>#</nowiki>}} przeskadzały na rozkład adresu strony na właściwy adres, parametry i nagłówek strony, co po rozkładzie wywoływana jest jego też jego funkcja odwrotna {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}}, a tak powstałe znaki {{Code|{{Nowiki|&#35;}}}} ze wszystkich tych kodów {{Code|<nowiki>#</nowiki>}} według pewnych funkcji modułu {{Code|{{ld2|Html}}}}, że one nie zostaną odkodowane, bo są one pomijane. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeHashKoduHtmlTekstu(tekst)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - tekst do przetworzenia. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Kody do zamienienia local tekst="&num;, &#35; i &#x23;"; -- Przetwarzanie tekstu local tekst2,ile,ile2=html_modul.EncodeHashKoduHtmlTekstu(tekst); </syntaxhighlight> Wynik jest pod zmienną: <syntaxhighlight lang="lua"> -- Wszystkie możliwe warianty funkcja zamieniła na to samo, czyli na: "&amp;num;" kodu HTML "&num;" dla znaku "#"; local tekst2,ile,ile2="&amp;num;, &amp;num; i &amp;num;",3,3; </syntaxhighlight> == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == Jeżeli dokonano zamiany możliwych kodów {{Code|{{Nowiki|&num;}}}}, {{Code|{{Nowiki|&#35;}}}} i {{Code|{{Nowiki|&#x23;}}}} na {{Code|{{Nowiki|&num;num}}}}, wtedy druga zmienna jest większa od zera, wtedy możliwa jest tego zamiana na kod {{Code|{{Nowiki|&#35;}}}} kodu {{Code|{{Nowiki|&num;num}}}}, używając tej funkcji. Funkcja używana, gdy właściwy adres, parametry i nagłówek strony zostały po rozłączeniu na te części z pełnego adresu strony, wraz z innymi funkcjami odkodowującymi znaki niektóre {{Strong|HTML}}, oraz jeżeli ciało jej wersji prostej została wywołana wcześniej. Jest to odwrotność funkcji {{Code|{{sr|#p.EncodeHashKoduHtmlTekstu(tekst)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeHashKoduHtmlTekstu(tekst,ile)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - tekst do przetworzenia, * {{Code|ile}} - {{Code|<nowiki>ile>0</nowiki>}}, jeżeli dokonano możliwych zamian kodów znaku {{Code|<nowiki>#</nowiki>}} na {{Code|{{Nowiki|&num;num}}}}. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Zamienione wcześniej kody: tekstu "&num;, &#35; i &#x23;", kolejno na "&amp;num;"; local tekst="&amp;num;, &amp;num; i &amp;num;"; -- Odkodowanie znaków "&amp;num;" w tekście; local tekst2=html_modul.DecodeHashKoduHtmlTekstu(tekst,3); </syntaxhighlight> Wynik jest ukryty pod zmienną: <syntaxhighlight lang="lua"> local tekst2="&#35;, &#35; i &#35;"; </syntaxhighlight> == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == Jeżeli mamy jakieś kody {{Strong|HTML}}, to aby one nie przeszkadzały w rozkładzie na właściwy adres, parametry i nagłówek strony, to te tam {{Code|<nowiki>#</nowiki>}} należy zamienić na {{Code|{{Nowiki|&num;}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeTempHashKoduHtmlTekstu(tekst)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - tekst do przetworzenia. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Mamy tutaj kody HTML znaku: "#", czyli: "&#35;" i "&#x23;" oraz jeden od spacji: "&#32;";, a tam "#"zamieniamy na "&num;"; local tekst="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; -- Otrzymamy przetworzony tekst oraz ile uzyskamy znaków z kodem HTML dziesiętnym "ile1" i szesnastkowym "ile2"; local tekst2,ile1,ile2=html_modul.EncodeTempHashKoduHtmlTekstu(tekst); </syntaxhighlight> Wynik tego jest pod zmienną: <syntaxhighlight lang="lua"> local tekst2,ile1,ile2="https://pl.wikibooks.org/wiki/Strona&&num;32;główna&&num;35;&&num;35;&&num;x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony",3,1; </syntaxhighlight> == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == Jeżeli mamy jakieś kody {{Strong|HTML}}, to aby one nie przeszkadzały w rozkładzie na właściwy adres, parametry i nagłówek strony, to te tam {{Code|<nowiki>#</nowiki>}} należy zamienić na {{Code|{{Nowiki|&num;}}}}. One tak zostały zamienione funkcją {{Code|{{sr|#p.EncodeTempHashKoduHtmlTekstu(tekst)|p=Html}}}}. Po rozłożeniu na trzy części pełnego adresu strony, tzn. na właściwy adres, parametry i nagłówek strony, możemy wywołać dla każdej z nich tę funkcję, wykonując operację odwrotną. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeTempHashKoduHtmlTekstu(tekst,ile1,ile2)...end; </syntaxhighlight> Parametry zwykłe funkcji: * {{Code|tekst}} - tekst do przetworzenia i po rozdzieleniu na trzy części, * {{Code|ile1}} - ile jest przetworzonych kodów dziesietnych prez funkcje do rozważanej prostej, * {{Code|ile2}} - ile jest przetworzonych kodów szesnastkowych przez funkcją do rozważanej prostej. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Mamy tutaj kody HTML znaku: "#", czyli: "&&num;35;" i "&&num;x23;" oraz jeden od spacji: "&&num;32;";, a tam "#"zamieniamy na "&num;"; local tekst="https://pl.wikibooks.org/wiki/Strona&&num;32;główna&&num;35;&&num;35;&&num;x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; -- Otrzymamy przetworzony tekst, do którego wsadzamy ile uzyskamy znaków z kodem HTML dziesiętnym "ile1" i szesnastkowym "ile2" w wywołaniu local tekst,ile1,ile2=p.EncodeTempHashKoduHtmlTekstu(tekst); local tekst2=html_modul.EncodeTempHashKoduHtmlTekstu(tekst,3,1); </syntaxhighlight> Wynik tego jest pod zmienną: <syntaxhighlight lang="lua"> local tekst2="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; </syntaxhighlight> == {{Code|p.AdresDomniemanieBezProtokolarnyEncodeURL(adres,...)}} == Funkcja domyślnie koduje adres bezprotokolarny, a z podaniem drugiej wartości {{Code|true}} protokolarny. Funkcja wykorzystuje funkcję {{Code|{{sr|#p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)|p=Html}}}}. A jeżeli druga wartość odpowiada prawdziwości, to korzystamy z {{Code|{{sr|#p["UrlBezProtokołu"](frame)|p=Html}}}} na rozkład na adres bezprotokolarny i protokół. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.AdresDomniemanieBezProtokolarnyEncodeURL(adres,protokolarny)...end; </syntaxhighlight> Parametry: * {{Code|adres}} - adres do zakodowania, * {{Code|protokolarny}} - czy ma rozkładać adres na nazwę strony i protokół. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Adres protokonalny; local adres11="https://pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; local adres12=html_modul.AdresDomniemanieBezProtokolarnyEncodeURL(adres11,true); -- Adres bezprotokonalny; local adres21="//pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; local adres22=html_modul.AdresDomniemanieBezProtokolarnyEncodeURL(adres21,false); </syntaxhighlight> Wynik wartości {{Code|adres12}} i {{Code|adres12}} jest: <syntaxhighlight lang="lua"> -- Zakodowany adres z protokołem local adres12="https://pl.wikibooks.org/wiki/Strona_g%C5%82%C3%B3wna?action=edit&section=2#Nag%C5%82%C3%B3wek%20strony"; -- Zakodowany adres bez protokołu local adres22="//pl.wikibooks.org/wiki/Strona_g%C5%82%C3%B3wna?action=edit&section=2#Nag%C5%82%C3%B3wek%20strony"; </syntaxhighlight> == {{Code|p.UriEncode(frame)}} == Funkcja do kodowania adresów tylko z protokołem, wartości bez protokołu nie obsługuje. Wykorzystuje {{Code|{{sr|#p.AdresDomniemanieBezProtokolarnyEncodeURL(adres,...)|p=Html}}}}. Do wyszukiwania adresów jest brana funkcja {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.UriEncode(frame)...end; </syntaxhighlight> Parametry tablicy ramki tablicy transportu: * {{Code|html}} - adres z protokołem strony. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|html}}. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Adres protokonalny; local adres="https://pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; -- Równoważnie: local adres2=html_modul.UriEncode{html=adres,}; local adres2=html_modul.UriEncode(adres); </syntaxhighlight> Wynik jest w zmiennej: <syntaxhighlight lang="lua"> local adres2="https://pl.wikibooks.org/wiki/Strona_g%C5%82%C3%B3wna?action=edit&section=2#Nag%C5%82%C3%B3wek%20strony"; </syntaxhighlight> == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == Funkcja blokuje odkodowywanie możliwych kodów {{Strong|HTML}} znaku {{Code|<nowiki>#</nowiki>}}, w tym celu wywoływana jest funkcja: {{Code|{{sr|#p.KodowanieOmijanieFunkcyjne(html,...)|p=Html}}}}, do omijania tego znaku, funkcja omija tylko znaki zapisane w kodach {{Strong|HTML}}, tzn. {{Code|{{Nowiki|&#35}}}}, w tym celu wszystkie kody tego znaku zamieniamy na jeden, przed wywołaniem tej funkcji, funkcjami: {{Code|{{sr|#p.EncodeHashKoduHtmlTekstu(tekst)|p=Html}}}} i {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}}. Ta funkcja w pierwszym kroku, w nim we wspomnianej funkcji wywołanej w funkcji anonimowej, wywołuje funkcję dekodujące znaki, czyli: {{Code|{{sr|#p.DecodeKoduHTMLZnaku(tekst)|p=Html}}}}, do odkodowania kodów, {{Strong|HTML}}, dziesiętnych, szesnastkowych i literowych. Na samym końcu kodowane są specjalne znaki na podstawie: {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}, na kody {{Strong|HTML}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)...end; </syntaxhighlight> Parametry: * {{Code|elementy_adresu_strony}} - funkcja do podstawowego kodowania adresu. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.EncodePodstawoweHtmlTekstu(adres); </syntaxhighlight> Wartość zmiennej jest ukryta pod: <syntaxhighlight lang="lua"> local adres2="Szablon:Link_wewnętrzny&#63;action&#61;edit&#35;Obsługa&#63;"; </syntaxhighlight> == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == Gdy mamy problem (przypadek) z parametrami adresu strony,wtedy do kodowania wywoływana jest funkcja {{Code|{{sr|#p.EncodeZaawansowanyParametryHtml(adres,...)|p=Html}}}}, a gdy posługujemy się właściwym adresem strony lub nagłówkiem, wtedy dekodujemy '''URL''' funkcją {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, następnie {{Code|{{sr|#p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)|p=Html}}}}, i jeżeli mały włączone kodowanie, następnie {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeElementyAdresuStrony(elementy_adresu_strony,czy_parametry_strony,z_kodowaniem)...end; </syntaxhighlight> Parametry: * {{Code|elementy_adresu_strony}} - element adresu strony, * {{Code|czy_parametry_strony}} - czy parametry strony rozważać, jako że wtedy jest taki adres jako parametry, * {{Code|z_kodowaniem}} - czy jest włączone kodowanie funkcji po odkodowaniu i pewnych operacjach w tej funkcji. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local elementy_adresu_strony="Obsługa?"; local elementy_adresu_strony2=html_modul.EncodeElementyAdresuStrony(elementy_adresu_strony,false,true); </syntaxhighlight> Wartość zmiennej jest ukryta pod: <syntaxhighlight lang="lua"> local elementy_adresu_strony2="Obs%C5%82uga%26%2363%3B"; </syntaxhighlight> == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == Funkcja korzysta do dekodowania na samym początku '''URL''' {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a na końcu {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}, jeżeli jest włączone kodowanie, między czasie korzysta z {{Code|{{sr|#p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)|p=Html}}}}. Główny elementem funkcyjnym jest {{Code|{{sr|#p.EncodeZaawansowanyParametryHtml(adres,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.AdresProjektuEncodeHtml(frame,z_kodowaniem,protokolarny)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|z_kodowaniem}} - czy końcowo kodować, * {{Code|protokolarny}} - czy uważać przy kodowaniu na protokoły pełnych adresów stron. Parametry tablicy ramki tabeli transportu: * {{Code|html}} - adres do kodowania, * {{Code|encode}} - czy kodować. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|html}}. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="https://pl.wikibooks.org/wiki/Strona_&główna?&?action=edit&section=2&title=Nazwa strony szablonu: {{!}}#Nagłówek strony"; local adres2=html_modul.AdresProjektuEncodeHtml(adres,false,true); local adres3=html_modul.AdresProjektuEncodeHtml(adres,true,true); </syntaxhighlight> Wartość zmiennej jest ukryta pod: <syntaxhighlight lang="lua"> local adres2="https://pl.wikibooks.org/wiki/Strona_&#38;główna&#63;&#38;?action=edit&section=2&title=Nazwa strony szablonu: &#123;&#123;!&#125;&#125;#Nagłówek strony"; local adres3="https://pl.wikibooks.org/wiki/Strona_%26%2338%3Bg%C5%82%C3%B3wna%26%2363%3B%26%2338%3B?action=edit&section=2&title=Nazwa%20strony%20szablonu%3A%20%26%23123%3B%26%23123%3B%21%26%23125%3B%26%23125%3B#Nag%C5%82%C3%B3wek%20strony"; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> h4iu0aw9t7ee01ewf6bwz74sjru4tpm 541344 541343 2026-04-30T06:56:41Z Persino 2851 /* {{Code|p.KodowanieOmijanieFunkcyjne(html,...)}} */ 541344 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ę dziesiętnymi, szesnastkowymi i literowymi kodami {{Strong|HTML}} i zamieniania ich na odpowiednie znaki, zamieniania znaków na ich kody dziesiętne, 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 łączenie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p.KodowanieOmijanieFunkcyjne(html,...)}} == Funkcja wywołuje funkcję modułu {{Code|{{ld2|Szeregi}}}} zwaną {{Code|{{sr|#p.SzeregiOmijanieFunkcyjne(tekst,...)|p=Szeregi}}}}. Domyślnym wzorem jest {{Code|<nowiki>&([^&;%s]+);</nowiki>}}, ale można go zmienić na inny. Drugą funkcją podawaną do tej funkcji jest domyślnym obiektem funkcyjnym anonimowym, który nie podaje się do funkcji w nagłówku: <syntaxhighlight lang="lua"> function(kod) return "&"..kod..";"; end </syntaxhighlight> Gdzie {{Code|kod}} jest elementem przechwytywanym kodu {{Strong|HTML}}, który jest określony poprzez nawiasy okrągłe we wzorze podawanym jako argument lub, jeśli jest on równy {{Code|nil}}, wtedy we wzorze domyślnym, który w takim razie jest rozpatrywany. Funkcja służy do omijania wszystkich kodów {{Strong|HTML}} lub tylko niektórych i robienia na nich operacji za pomocą funkcji podawanej jako ostatni parametr. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.KodowanieOmijanieFunkcyjne(html,normalnie,wzor,funkcja)...end; </syntaxhighlight> Parametry: * {{Code|html}} - ciąg do przetworzenia, w częściach bez parametrów omijanych, * {{Code|normalnie}} - czy ma przetwarzać tekst pomijając, w przeciwnym wypadku tak nie robi, * {{Code|wzor}} - wzór do elementów pomijanych, wzór może mieć tylko jeden element przechwytywany, * {{Code|funkcja}} - funkcja robiąca operacje na przetworzonych subciągach bez elementów pomijanych. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest tekst wywołania: \"&#35;\""; local tekst2=html_modul.KodowanieOmijanieFunkcyjne(tekst,true,"&(#35);",function(tekst) return mw.uri.encode(tekst); end); </syntaxhighlight> Wynik jest: <syntaxhighlight lang="lua"> local tekst2="Oto+jest+tekst+wywo%C5%82ania%3A+%22&#35;%22"; </syntaxhighlight> == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody dziesiętne {{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 się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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 się tekst do zamiany kodów {{Strong|HTML}}, dziesiętnych i szesnastkowych, na znaki. 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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 tekście (w zawartości pomiędzy tagami tagu {{Tag|nowiki}}, by potem je tam umieścić, by pierwotna zawartość równała się tekstowi wyświetlanemu (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}})), wikikodu na kody dziesiętne {{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 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 się tekst do zamiany znaków, z zestawu znaków specjalnych wskazanych w funkcji, występujących w tagach języka '''HTML''' do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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 się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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,normalnie)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}. Parametry ramki funkcji tablicy transportu: * {{Code|html}} - zmienna, pod którym wyszukuje się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego kodu {{Strong|HTML}}, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}, jeżeli jej wartość odpowiada wartości logicznej {{Code|false}}, wtedy liczy się jej wersja parametrowa funkcji. 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|html}}. 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 samym początku, to jest określane 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 się tekst do zamiany z podanego zestawu znaków pierwszych znaków listy, mechanizmu {{Strong|MediaWiki}}, do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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 zamienia znaki {{Code|<nowiki>=%?&</nowiki>}} na kody dziesiętne {{Strong|HTML}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Funkcja potrafi opcjonalnie omijać kody {{Strong|HTML}}, w zależności od podanego drugiego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame,normalnie)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}. Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego kodu {{Strong|HTML}}, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}, jeżeli jej wartość odpowiada wartości logicznej {{Code|false}}, wtedy liczy się jej wersja parametrowa funkcji. 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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 się tekst do zamiany znaków przypisania {{Code|{{=}}}} do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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 dziesiętne {{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 się tekst do zamiany ze znaku dwukropka do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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 dziesiętny {{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 dziesiętny {{Strong|HTML}}, * {{Code|2}} - czy znak {{Code|{{Nowiki|&}}}} ma być zamieniany na {{Code|{{Nowiki|&amp;}}}}, a znak {{Code|<nowiki>#</nowiki>}} na {{Code|{{Nowiki|&num;}}}}. 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}}. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}. 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 === Zamienia ściśle określone znaki (zestaw kodów znajduje się na stronie: {{Code|{{ls2|KodyHTMLZnakówWikiCiągu/opis}}}}) na kody dziesiętne {{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["KodyHTMLZnakówWikiCiągu"](frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|1}} - ciąg, pod którym są możliwe ściśle określone znaki są zamieniane na kod {{Strong|HTML}}, ciąg ten jest ze znakami wiki w UTF8, * {{Code|2}} - czy znak {{Code|{{Nowiki|&}}}} ma być zamieniany na {{Code|{{Nowiki|&amp;}}}} i {{Code|<nowiki>#</nowiki>}} na {{Code|{{Nowiki|&num;}}}}. 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}}. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="k{{s"; -- Równoważne: local tekst2=html_modul["KodyHTMLZnakówWikiCiągu"]{[1]=tekst,}; -- Równoważne: local tekst2=html_modul["KodyHTMLZnakówWikiCiągu"]{args={[1]=tekst,},}; local tekst2=html_modul["KodyHTMLZnakówWikiCiągu"](znak); -- Równoważne: local tekst3=html_modul["KodyHTMLZnakówWikiCiągu"]{[1]=tekst,[1]="tak",}; local tekst3=html_modul["KodyHTMLZnakówWikiCiągu"]{args={[1]=tekst,[2]="tak",},}; </syntaxhighlight> Wynikiem działania funkcji jest: <syntaxhighlight lang="lua"> local tekst2="k&#123;&#123;s"; local tekst3="k&amp;&num;123;&amp;&num;123;s"; </syntaxhighlight> Szablonowo taką zamianę możemy napisać: * {{Code|{{s|KodyHTMLZnakówWikiCiągu|k{{s|((}}s}}}} → {{Tt|{{KodyHTMLZnakówWikiCiągu|k{{((}}s}}}} * {{Code|{{s|Nowiki|{{s|KodyHTMLZnakówWikiCiągu|k{{s|((}}s}}}}}} → {{Tt|{{Nowiki|{{KodyHTMLZnakówWikiCiągu|k{{((}}s}}}}}} * {{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}}}}}} Równie dobrze możemy napisać takie wywołania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="mediawiki"> <!-- Wyświetla wynik: "k&#123;&#123;s"; --> {{#invoke:Html|KodyHTMLZnakówWikiCiągu|k{{((}}s|wyspecjalizowana=tak}} <!-- Wyświetla wynik: "k&amp;&num;123;&amp;&num;123;s"; --> {{#invoke:Html|KodyHTMLZnakówWikiCiągu|k{{((}}s|tak|wyspecjalizowana=tak}} </syntaxhighlight> == {{Code|p.EncodeId(...)}} == Funkcja służy do opcjonalnego dekodowania ciągów znakowych według {{Code|{{sr|#p.DecodeHtml(...)|p=Html}}}}, i cały ciąg od specjalnych znaków jest transformowany przez funkcję {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeId(id,bez_transformacji)...end; </syntaxhighlight> Parametry nieramkowe normalne funkcji: * {{Code|id}} - ciąg do przeinaczenia, * {{Code|bez_transformacji}} - gdy nie {{Code|false}} lub {{Code|nil}}, funkcja nie transformuje na podstawie: {{Code|{{sr|#p.DecodeHtml(...)|p=Html}}}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local id="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; local id2=html_modul.EncodeId(id,false); </syntaxhighlight> Wynikiem tego: <syntaxhighlight lang="lua"> local id2="https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link wewnętrzny&#38;action&#61;edit&#35;Obsługa"; </syntaxhighlight> Gdy: {{Code|bez_transformacji{{=}}true}}, funkcja działa jak: {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}, ale wtedy {{Code|frame{{=}}id}}, a przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local id="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; local id2=html_modul.EncodeId(id,true); </syntaxhighlight> Wynikiem działania jest wartość ostatniej zmiennej: <syntaxhighlight lang="lua"> local id2="https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link_wewn%C4%99trzny&#38;action&#61;edit&#35;Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == Usuwa z tekstu znak numer {{Code|8206}} zestawu {{lpg|Unicode}}, który można napisać, jeśli jest widoczny na ekranie komputera {{Code|&#8206;}} (znak {{Code|{{Nowiki|&#8206;}}}}). Ten znak oczywiście Unicode jest w grupie zwanej invisible Unicode characters i służy do ustawiania kierunku tekstu lewo do prawo. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)...end; </syntaxhighlight> Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tutaj jest zakodowany znak HTML, o kodzie dziesiętnym "&#8206;", składający się z trzech bajtów: "&#226;", "&#128;" i "&#142;"; local tekst="Oto jest znak: &#8206;."; -- Zamiana tego kodu na znak; tekst=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); -- Tekst bez tego znaku, bo on został w tym wywołaniu całkowicie usunięty; tekst=html_modul.UsuwanieSpecjalnychNieschematycznychSymboli(tekst); </syntaxhighlight> Wynikiem tego kodu jest wartość ukryta pod zmienną: <syntaxhighlight lang="lua"> local tekst="Oto jest znak: ."; </syntaxhighlight> == {{Code|p.EncodeWiki(...)}} == Funkcja transformuje kody {{Strong|HTML}} do znaku przy pomocy funkcji {{Code|{{sr|#p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)|p=Html}}}}, usuwa nieschematyczne znaki o kodzie {{Code|{{Nowiki|&#8206;}}}} dzięki funkcji: {{Code|{{sr|#p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)|p=Html}}}}, następnie opcjonalnie usuwa znaki będące odstępami lub dolnymi myślnikami z początku i końca tekstu, i zamienia wewnątrz znaki kolejne odstępów lub dolnych myślników na jeden dolny myślnik na podstawie {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, dalej zaraz funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.text.encode|n=mw.text.encode}}}} koduje tekst, tą funkcją {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeWiki(parametr,czy_nie_odstepy)...end; </syntaxhighlight> Parametry: * {{Code|parametr}} - tekst, który chcemy zakodować, * {{Code|czy_nie_odstepy}} - czy nie ma na tekst podziałać funkcją {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local parametr="__Oto jest znak: \"&#8206;\" i inne_znaki_w_URL: \"https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link wewnętrzny&#38;action&#61;edit&#35;Obsługa;\"__"; local parametr2=html_modul.EncodeWiki(parametr,false); local parametr3=html_modul.EncodeWiki(parametr,true); </syntaxhighlight> Wynikiem działania tej funkcji jest parametr {{Code|parametr2}} i {{Code|parametr3}}, którego wartości: <syntaxhighlight lang="lua"> local parametr2="Oto_jest_znak:_&quot;&quot;_i_inne_znaki_w_URL:_&quot;https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewnętrzny&amp;action=edit#Obsługa;&quot;"; local parametr3="__Oto jest znak: &quot;&quot; i inne_znaki_w_URL: &quot;https://pl.wikibooks.org/w/index.php?title=Szablon:Link wewnętrzny&amp;action=edit#Obsługa;&quot;__"; </syntaxhighlight> == {{Code|p.DecodeWiki(...)}} == Funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.text.decode|n=mw.text.decode}}}} dekoduje tekst, tą funkcją {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Następnie usuwa nieschematyczne symbole: {{Code|{{Nowiki|&#8206;}}}}, dzięki funkcji: {{Code|{{sr|#p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)|p=Html}}}}, następnie działa opcjonalnie funkcją, która usuwa znaki będące odstępami lub dolnymi myślnikami z początku i końca tekstu oraz zamieniając wewnątrz znaki kolejne odstępów lub dolnych myślników na jedną dolną spacją na podstawie {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeWiki(parametr,czy_nie_odstepy)...end; </syntaxhighlight> Parametry: * {{Code|parametr}} - tekst, który chcemy odkodować, * {{Code|czy_nie_odstepy}} - czy nie ma na tekst podziałać funkcją {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local parametr="__Oto jest znak: &quot;&#8206;&quot; i inne_znaki_w_URL: &quot;https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link wewnętrzny&#38;action&#61;edit&#35;Obsługa;&quot;__"; local parametr2=html_modul.DecodeWiki(parametr,false); local parametr3=html_modul.DecodeWiki(parametr,true); </syntaxhighlight> Wynikiem działania tej funkcji jest parametr {{Code|parametr2}} i {{Code|parametr3}}, którego wartość: <syntaxhighlight lang="lua"> local parametr2="Oto jest znak: \"\" i inne znaki w URL: \"https://pl.wikibooks.org/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa;\""; local parametr3="__Oto jest znak: \"\" i inne_znaki_w_URL: \"https://pl.wikibooks.org/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa;\"__"; </syntaxhighlight> == {{Code|p.IsEncodedHtml(...)}} == Funkcja sprawdza, czy można uznać, że funkcja jest zakodowana, tzn. dalej nie warto jej kodować przy pomocy funkcji: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}, czy dekodować, bo już można uznać ją za odkodowaną, czyli nie trzeba stosować funkcji: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}. Funkcja zwraca wartość {{Code|true}}, jak można uznać tekst za zakodowany i {{Code|false}}, gdy jest niezakodowana. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IsEncodedHtml(parametr,encode,encode_real)..end; </syntaxhighlight> Parametry funkcji: * {{Code|parametr}} - parametr do sprawdzenia - wymagany, * {{Code|encode}} - gdy jest sprawdzana tylko obecność znaku {{Code|%}}, * {{Code|encode_real}} - gdy jest sprawdzana, nie tylko obecność znaku {{Code|%}}, też czy {{Code|parametr}} jest ciągiem podporządkowanym wyrażeniu regularnemu {{Code|<nowiki>^[%w%p%s]*$</nowiki>}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Pierwszy przykład: local parametr1="abc?edit=action"; -- Wartość zmiennej obliczona jest: czy_tak1=true, czyli parametr1 można uznać za zakodowany; local czy_tak1=html_modul.IsEncodedHtml(parametr1,true,false); -- Drugi przykład: local parametr2="a%YTbc?edit=action;"; -- Wartość zmiennej obliczona jest: czy_tak2=false; czyli parametr2można uznać, że nie jest zakodowany; local czy_tak2=html_modul.IsEncodedHtml(parametr2,true,false); </syntaxhighlight> == {{Code|p.EncodeHtml(...)}} == Funkcja sprawdza, czy podany parametr do transformacji uznać za zakodowany, jeżeli za taki zostanie uznany, wtedy zostanie, to on zostanie potraktowany funkcją {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}, a jeżeli nie to zostanie wywołana funkcja: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}} (z parametrem "WIKI"). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeHtml(parametr,encode,encode_real,czy_nie_odstepy)...end; </syntaxhighlight> Parametry funkcji: * {{Code|parametr}} - parametr do transformacji kodowania, * {{Code|encode}} i {{Code|encode_real}} - te parametry to samo oznaczają, co w funkcji: {{Code|{{sr|#p.IsEncodedHtml(...)|p=Html}}}}, * {{Code|czy_nie_odstepy}} - to samo oznacza, co w funkcji {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}. {{Hr}} Przykłady pierwszy - podany tekst już zakodowany: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst do zakodowania; local parametr="abc___&#63;action&#61;edit&#38;section&#61;21&#35;nagłówek"; -- Tekst zostanie uznany za zakodowany, sprawdzane, czy on ma znaki "%", czyli on tego nie posiada; local parametr2=html_modul.EncodeHtml(parametr,true,false,false); </syntaxhighlight> Wynik zmiennej {{Code|parametr2}} jest ukryty pod jego wartością: <syntaxhighlight lang="lua"> -- Widzimy, że podwojone myślniki dolne zostały zamienione na pojedyncze, kody HTML zostały zamienione na znaki, a znak "&#38;", czyli "&" został zamieniony na "&amp;"; local parametr2="abc_?action=edit&amp;section=21#nagłówek"; </syntaxhighlight> {{Hr}} Przykłady drugi - podany tekst jeszcze nie zakodowany: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst do zakodowania; local parametr="a%YTbc___?action=edit;"; -- Tekst zostanie uznany za niezakodowany, czy on ma znaki "%", czyli on to posiada; local parametr2=html_modul.EncodeHtml(parametr,true,false,false); </syntaxhighlight> Wynik zmiennej {{Code|parametr2}} jest ukryty pod jego wartością: <syntaxhighlight lang="lua"> -- Widzimy, że znak "%" został zakodowany funkcją mw.uri.encode, podobnie tą funkcją zostały zakodowane: "?" i "="; local parametr2="a%25YTbc___%3Faction%3Dedit;"; </syntaxhighlight> == {{Code|p.DecodeHtml(...)}} == Funkcja sprawdza, czy {{Code|parametr}}, czy można uznać za zakodowany, a jeżeli można, to on zostanie w zależnosci od parametru {{Code|spacje}}, to odpowiednio zostanie wywołana {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a następnie w zależności od parametru (opis w parametrach) zostanie wywołana odpowiednia funkcja odkoduwująca lub kodująca {{Code|wiki}}. Jeżeli ciąg rzeczywiście jest uznany za niezakodowany jest podobnie odpowiednio z tylko z wywołaniami funkcji {{Code|wiki}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeHtml(parametr,spacje,encode,encode_real,czy_nie_odstepy)...end; </syntaxhighlight> Parametry:z * {{Code|parametr}} - parametr do odkodowania, * {{Code|spacje}} - gdy parametr odpowiada {{Code|true}} używa funkcji {{Code|{{sr|#p.DecodeWiki(...)|p=Html}}}}, w przeciwnym wypadku: {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}, ale wpierw musi zostać wywołana funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}} w przypadku, gdy ciąg zostanie uznany za zakodowany, jak to robi funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}, * {{Code|encode}} i {{Code|encode_real}} - te parametry są używane przez funkcje {{Code|{{sr|#p.IsEncodedHtml(...)|p=Html}}}}, * {{Code|czy_nie_odstepy}} - gdy ciąg został uznany za niezakodowany, wtedy to jest drugi parametr funkcji: {{Code|{{sr|#p.DecodeWiki(...)|p=Html}}}} lub {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Parametr zawiera znaki zakodowane funkcją mw.uri.encode i kody HTML znaków; local parametr="a%25YTbc___%3Faction%3Dedit&#38;section&#61;23;"; local parametr2=html_modul.DecodeHtml(parametr,true); </syntaxhighlight> Wynik funkcji jest ukryty pod adresem: <syntaxhighlight lang="lua"> -- Funkcja została uznana za zakodowaną i odkodowano ją funkcją mw.uri.decode, dalej dwa dolne myślniki zostały zamienione na jedną spację, a kody HTML zostały zamienione na odpowiednie znaki; local parametr2="a%YTbc ?action=edit&section=23;"; </syntaxhighlight> == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == Szuka atrybutów w cudzysłowach i w nich elementy {{Code|<nowiki><>&</nowiki>}} zamienia na kody dziesiętne {{Strong|HTML}}, a także znaki lewego ukośnika {{Code|<nowiki>\</nowiki>}} też na to. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)...end; </syntaxhighlight> Parametry: * {{Code|znacznik}} - atrybut do przetwarzania, aby w nim zamienić niektóre znaki, które przeszkadzają w analizie na kody, o odpowiednim formacie, {{Strong|HTML}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"Znaki<>\\\"\">To jest zawartość</span>"; local tekst2=html_modul.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(tekst); </syntaxhighlight> Wartość tej zmiennej jest ukryta pod {{Code|tekst2}}: <syntaxhighlight lang="lua"> -- Widzimy, że został sam jeden atrybut ze znakami HTML wewnątrz; local tekst2="<span id=\"Znaki&lt;&gt;&#92;&#34;\">To jest zawartość</span>"; </syntaxhighlight> == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == Zamienia kody {{Strong|HTML}}, tzn.: {{Code|{{Nowiki|&lt;}}}}, {{Code|{{Nowiki|&gt;}}}} i {{Code|{{Nowiki|&amp;}}}}, na odpowiednio znaki, a także elementy {{Code|{{Nowiki|&#92;&#34;}}}} na {{Code|<nowiki>\"</nowiki>}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)...end; </syntaxhighlight> Parametry: * {{Code|value}} - parametr do transformacji niektórych kodów {{Strong|HTML}} na znaki. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="&lt;a href=\"/wiki/Strona?tytan1=1&amp;tytan2=2\" id=\"Strona:&#92;&#34;nazwa&#92;&#34;\"&gt;Zawartość znacznika&lt;/a&gt;"; local tekst2=html_modul.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(tekst); </syntaxhighlight> Otrzymana zawartość jest pod {{Code|tekst2}}: <syntaxhighlight lang="lua"> -- Widzimy, że kody odpowiednie HTML, tzn.: "&lt;", "&gt;" i "&amp;" zostały zamienione na odpowwiednie znaki; local tekst2="<a href=\"/wiki/Strona?tytan1=1&tytan2=2\" id=\"Strona:\\\"nazwa\\\"\">Zawartość znacznika</a>"; </syntaxhighlight> == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == Funkcja wydziela nagłówek z adresu strony, funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NagłówekStronyAdresu"]=function(frame,czy_nie_dolne_myslniki,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_nie_dolne_myslniki}} - gdy {{Code|true}}, jeśli w nagłówku nie ma prawa być dolnych myślników, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Funkcja usuwa zbędne odstępy i dolne myślniki na końcach nagłówka, i powtarzające się znaki będące odstępami lub dolnymi myślnikami są zastępowane przez jedną spację, gdy {{Code|czy_nie_dolne_myslniki}} równa jest wartości odpowiadającej {{Code|true}}, w przeciwnym wypadku zamieniana jest ona na jeden dolny myślnik. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_nie_dolne_myslniki}} (parametr funkcji), {{Code|2}} lub {{Code|z nie dolnymi z myślnikami}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local naglowek=html_modul["NagłówekStronyAdresu"](strona,true,tabela_nazw_adresu); local naglowek=html_modul["NagłówekStronyAdresu"]({strona=strona,["z nie dolnymi z myślnikami"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony, nagłówek usuwając z niego myślniki dolne i trimując zawartość; local naglowek="Nagłówek strony"; </syntaxhighlight> == {{Code|p["ParametryStronyAdresu"](frame,...)}} == Funkcja wydziela parametry z adresu strony, funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ParametryStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma suwać zbędne odstępy i dolne myślniki z parametrów adresu, wydzieloną z pełnego adresu strony, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local parametry=html_modul["ParametryStronyAdresu"](strona,true,tabela_nazw_adresu); local parametry=html_modul["ParametryStronyAdresu"]({strona=strona,["czy naprawiać"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony parametry, usuwając z niego zbędne odstępy i myślniki dolne; local parametry="action=edit&section=2"; </syntaxhighlight> == {{Code|p["NazwaStronyAdresu"](frame,...)}} == Funkcja wydziela nazwę strony z adresu strony, funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwaStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma suwać zbędne odstępy i dolne myślniki z adresu strony, bez parametrów i nagłówka, wydzieloną z pełnego adresu strony, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local parametry=html_modul["NazwaStronyAdresu"](strona,true,tabela_nazw_adresu); local nazwa_strony=html_modul["NazwaStronyAdresu"]({strona=strona,["czy naprawiać"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony nazwę strony adresu, usuwając z niego zbędne odstępy i myślniki dolne; local nazwa_strony="https://pl.wikibooks.org/wiki/Strona_główna"; </syntaxhighlight> == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == Funkcja wydziela nazwę strony z parametrów adresu strony. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["NazwaStronyZParametrówStronyAdresu"]=function(frame,czy_naprawiaj)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma suwać zbędne odstępy i dolne myślniki z parametrów strony adresu, i czy zamieniać je na pojedyncze spacje wewnątrz nazwy artykułu wydzieloną z parametrów strony. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}} lub {{Code|parametry}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}} lub {{Code|parametry}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="title=Strona ___ główna & action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; -- Równoważne: local parametry=html_modul["NazwaStronyZParametrówStronyAdresu"](strona,true); local nazwa_strony=html_modul["NazwaStronyZParametrówStronyAdresu"]({parametry=strona,["czy naprawiać"]=true,},nil); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony nazwę artykułu, usuwając z niego zbędne odstępy i myślniki dolne; local nazwa_strony="Strona główna"; </syntaxhighlight> == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == Funkcja poprawia pełny adres strony, rozdzielając ją na części, a później łącząc. Funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma naprawiać pełny adres strony, działając w sposób specyficzny w zależności od funkcji, która operuje na jej częściach, wykorzystując funkcje, które są napisane w linii zaraz poniżej, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local parametry=html_modul["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](strona,true,tabela_nazw_adresu); local adres=html_modul["PoprawAdresNagłówkaOrazParametrówStronyAdresu"]({strona=strona,["czy naprawiać"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość pełnego adresu strony poprawiona jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z pełnego adresu strony adres, parametry i nagłówek, naprawione i złączone ze sobą w pełny poprawiony adres; local adres="https://pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; </syntaxhighlight> == {{Code|p.URLStrona(frame)}} == Funkcja z adresu '''URL''' wydziela nazwę serwera i nazwę strony. On nie może zawierać w sobie protokołu, tylko musi zaczynać od {{Code|<nowiki>//</nowiki>}}. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.URLStrona(frame)...end; </syntaxhighlight> Parametry ramki: * {{Code|1}} lub {{Code|url}} - adres strony, * {{Code|2}} lub {{Code|ukośnik}} - czy do nazwy strony ma wliczać ukośnik. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"): local url="//pl.wikibooks.org/wiki/Strona_artykułu"; local serwer,nazwa=html_modul.URLStrona{url=url,["ukośnik"]=true,}; </syntaxhighlight> Wartości zmiennych kryją się pod: <syntaxhighlight lang="lua"> -- Widzimy, że nazwa serwera jest bez prawych ukośników; local serwer="pl.wikibooks.org"; -- Nazwa strony zaczyna się bez ukośnika, bo powiedzieliśmy funkcji, by nie brał prawych ukośników, które są na początku nazwy strony, bez nazwy serwera i protokołu, ale w sobie może mieć on, ale nie musi; local nazwa="wiki/Strona_artykułu"; -- Gdyby było ["ukośnik"]=false, to wtedy otrzymalibyśmy inny wynik, czyli: local nazwa="/wiki/Strona_artykułu"; </syntaxhighlight> == {{Code|p["UrlBezProtokołu"](frame)}} == Funkcja adresowi z protokołem usuwa to właśnie, a jak podamy adres „mail”, to podaje nazwę tego adresu, bez niego. Drugą zwracaną nazwą jest nazwa protokołu,a jak się nie da go wyznaczyć, to funkcja zwraca wartość {{Code|nil}}. Trzecia wartość, to numer sposoby, a jeżeli żaden sposób nie pasuje, to ta wartość jest {{Code|-1}}, a gdy adres mail {{Code|1}}, dla adresu z protokołem {{Code|2}}, a dla adresu bez protokołu {{Code|3}}. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UrlBezProtokołu"]=function(frame)...end; </syntaxhighlight> Parametry ramki: * {{Code|1}} lub {{Code|url}} - adres strony, ewentualnie z opcjonalnym protokołem. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}} lub {{Code|url}}. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local mail="użytkownik@skrzynka.org"; -- Równoważnie: local adres1,protokol1,sposob1=html_modul["UrlBezProtokołu"](mail); local adres1,protokol1,sposob1=html_modul["UrlBezProtokołu"]{url=mail,}; --- local url="https://pl.wikibooks.org/wiki/Strona"; -- Równoważnie: local adres2,protokol2,sposob2=html_modul["UrlBezProtokołu"](url); local adres2,protokol2,sposob2=html_modul["UrlBezProtokołu"]{url=url,}; --- local url="//pl.wikibooks.org/wiki/Strona"; -- Równoważnie: local adres3,protokol3,sposob3=html_modul["UrlBezProtokołu"](url); local adres3,protokol3,sposob3=html_modul["UrlBezProtokołu"]{url=url,}; --- local url="pl.wikibooks.org/wiki/Strona"; -- Równoważnie: local adres4,protokol4,sposob4=html_modul["UrlBezProtokołu"](url); local adres4,protokol4,sposob4=html_modul["UrlBezProtokołu"]{url=url,}; </syntaxhighlight> Wyniki otrzymane z powyższych przykładów są: <syntaxhighlight lang="lua"> local adres1,protokol1,sposob1="//skrzynka.org","mail",1; local adres2,protokol2,sposob2="//pl.wikibooks.org/wiki/Strona","https",2; local adres3,protokol3,sposob3="//pl.wikibooks.org/wiki/Strona",nil,3; local adres4,protokol4,sposob4="//pl.wikibooks.org/wiki/Strona",nil,-1; </syntaxhighlight> == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == Zamienia kody {{Strong|HTML}}, tzn. literowe (ogólny wzór {{Code|<nowiki>&(%a+);</nowiki>}}), dziesiętne (ogólny wzór {{Code|<nowiki>&#(%d+);</nowiki>}}) i szesnastkowe (ogólny wzór {{Code|<nowiki>&#x(%x+);</nowiki>}}) na odpowiednie znaki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeKoduHTMLZnaku(tekst)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tekst}} - tekst do zamienienia z dziesiętnymi, szesnastkowymi i literowymi kodami {{Strong|HTML}} na odpowiednie znaki. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst z kodami HTML: literowymi, dziesiętnymi i szesnastkowymi; local tekst="Oto jest link: &#x5B;&#x5B;Strona&#124;Nazwa linku&#93;&#x5D;, a w nim spacje niełamliwe&nbsp;i inne znaki: z alfabetu greckiego jak: &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;"; -- Wywołanie funkcji odkodujący kody HTML; local tekst2=html_modul.DecodeKoduHTMLZnaku(tekst); </syntaxhighlight> Otrzymany wynik jest pod zmienną: <syntaxhighlight lang="lua"> -- Widzimy, że tekst został zdekodowany ze znaków HTML; local tekst2="Oto jest link: [[Strona|Nazwa linku]], a w nim spacje niełamliwe i inne znaki: z alfabetu greckiego jak: αΑβΒγΓδΔεΕζΖηΗθΘιΙκΚλΛμΜνΝξΞοΟπΠρΡσΣτΤυΥφΦχΧψΨωΩ"; </syntaxhighlight> == {{Code|p.ZamianaEncodeTekst(tekst)}} == Adres strony dekoduje funkcją: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, następnie koduje, jeszcze więcej niż było na samym początku, według: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaEncodeTekst(tekst)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - tekst do odkodowania i zakodowania jeszcze więcej niż było na początku zakodowane. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; local tekst2=html_modul.ZamianaEncodeTekst(tekst); </syntaxhighlight> Wynikiem funkcji, co kryje się pod zmienną {{Code|tekst2}}: <syntaxhighlight lang="lua"> local tekst2="https%3A%2F%2Fpl.wikibooks.org%2Fw%2Findex.php%3Ftitle%3DSzablon%3ALink_wewn%C4%99trzny%26action%3Dedit%23Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == Funkcja wyszukuje tekst do zamiany i działa na niego funkcją: {{Code|{{sr|#p.ZamianaEncodeTekst(tekst)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)...end; </syntaxhighlight> Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst nie do końca zakodowany wydzielonego według poniższego wzoru; local tekst="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obsługa"; -- Wzór, który wydziela części do kodowania jeszcze bardziej niż były na samym początku; local wzor="[^/%?%=&:%#]+"; -- Wywołanie funkcji kodującej; local tekst2=html_modul.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor); </syntaxhighlight> Wynikiem funkcji, co kryje się pod zmienną {{Code|tekst2:}} <syntaxhighlight lang="lua"> -- Zakodowało jeszcze więcej niż na samym początku było zakodowane; local tekst2="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.StronaParametryIdentyfikacjaAdresuHtml(adres)}} == Funkcja z całkowitego adresu składający się z adresu właściwego, parametrów i nagłówka, rozdzielane jest na trzy części, z których się składa. Funkcja sprawdza, czy jakikolwiek kody {{Strong|HTML}} występują w pełnym adresie strony, jeżeli są to przedtem koduje jeszcze lepiej kody znaków {{Code|<nowiki>#</nowiki>}}, przy pomocy funkcji: {{Code|{{sr|#p.EncodeHashKoduHtmlTekstu(tekst)|p=Html}}}}, a później w kodach {{Strong|HTML}} znak {{Code|<nowiki>#</nowiki>}} jest zamieniany na kod literowy {{Strong|HTML}}, czyli: {{Code|{{Nowiki|&num;}}}}, funkcją: {{Code|{{sr|#p.EncodeTempHashKoduHtmlTekstu(tekst)|p=Html}}}} (jeżeli w adresie kody istnieją), wtedy cos powstaje w rodzaju dla kodu dziesietnego: {{Code|<nowiki>&&num;(%d+);</nowiki>}}, i szesnastkowego: {{Code|<nowiki>&&num;x(%x+);</nowiki>}} - gdzie w nich {{Code|<nowiki>#</nowiki>}} został zamieniony na {{Code|{{Nowiki|&num;}}}}, które są przedstawione według wyrażeń regularnych {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja rozdziela to na trzy części, a później odkodowuje każdą część funkcją: {{Code|{{sr|#p.DecodeTempHashKoduHtmlTekstu(tekst,...)|p=Html}}}} (jeżeli w adresie kody w ogóle istniały), i podobnie później: {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}} (jeżeli kody znaku: {{Code|<nowiki>#</nowiki>}}, były wcześniej). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.StronaParametryIdentyfikacjaAdresuHtml(adres)...end; </syntaxhighlight> Parametry: * {{Code|adres}} - adres do potrzelenia na trzy części. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="https://pl.wikibooks.org/wiki/Strona&#32;główna&num;&#x23;&#35;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; -- Adresstrony jedynie rozkładaa się na: "strona", "parametry" i "nagłówek"; local strona,parametry,naglowek=html_modul.StronaParametryIdentyfikacjaAdresuHtml(adres); </syntaxhighlight> Otrzymane wartości tych zmiennych kryją się pod adresami: <syntaxhighlight lang="lua"> local strona,parametry,naglowek="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#35;To_nie_jest nagłówek","action=edit&section=2","Nagłówek strony",3; </syntaxhighlight> Funkcja zwraca trzy wartości, tzn. adres właściwy (bez parametrów i nagłówka), parametry (używane jako dodatek do adresów przy formułowaniu formularzy) i nagłówek (który jest adresem na stronie do odpowiedniego elementu o danym atrybucie: {{Code|id}}). == {{Code|p.TworzenieAdresuHtml(strona,...)}} == Funkcja łączy, stronę, parametry i nagłówek strony, w pełną nazwę strony (adresu), dalej jest uruchamiana funkcja ddekodująca ciagi znakowe: {{Code|{{Nowiki|&amp;&num;}}}}. Funkcja wykorzystuje do dekodowania tego {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TworzenieAdresuHtml(strona,parametry,naglowek)...end; </syntaxhighlight> Parametry: * {{Code|strona}} - nromalny adres strony, bez parametrów i nagłówka, * {{Code|parametry}} - parametry strony w formacie {{Code|nazwa{{=}}wartość}} oddzielone od siebie znakiem {{Code|<nowiki>&</nowiki>}}, * {{Code|nagłówek}} - nagłówek linkujący do {{Code|id}} jakiegos elementyna stronie, Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona,parametry,naglowek,ile="https://pl.wikibooks.org/wiki/Strona&#32;główna&num;&#35;&#x23;To_nie_jest nagłówek","action=edit&section=2","Nagłówek strony",3; local adres=html_modul.TworzenieAdresuHtml(strona,parametry,naglowek); </syntaxhighlight> Otrzymany pełny pojedynczy adres strony, z normalnym adresem strony z parametrami i nagłówkiem, jest ukryta: <syntaxhighlight lang="lua"> local adres="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#35;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; </syntaxhighlight> Funkcja zwraca całkowity adres z adresem właściwym, parametrami (po {{Code|<nowiki>?</nowiki>}}, jeżeli po nim występują wartości przyrównane nazwą zmiennych {{Strong|HTML}}) i nagłówkiem (po {{Code|<nowiki>#</nowiki>}}). == {{Code|p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)}} == Pełny adres strony, bezprotokolarny (lub protokolarny, jeżeli rozdzielimy, w pierwszej funkcji anonimowej w tej nagłówku, na protokół i adres bezprotokolarny, czyli na dwie części, zrobimy operacje, a później je złączymy w nim), linków zewnętrznych lub wewnętrznych, z adresem właściwym, parametrami i nagłówkiem strony, po podziale na je trzy części funkcją {{Code|{{sr|#p.StronaParametryIdentyfikacjaAdresuHtml(adres)|p=Html}}}}, następnie na każdą z tych elementów działamy odpowiednimi funkcjami, a potem ich wyniki łączymy w pełny adres strony funkcją {{Code|{{sr|#p.TworzenieAdresuHtml(strona,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,funkcja_strona,funkcja_parametry,funkcja_naglowek)...end; </syntaxhighlight> Parametry: * {{Code|adres}} - pełny adres do przetworzenia, * {{Code|funkcja_strona}} - funkcja, którą działamy na właściwy adres strony, bez parametrów i nagłówka, * {{Code|funkcja_parametry}} - funkcja, którą działamy na parametry adresu strony, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek strony adresu. Przykład takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local function ParametryEncodeURL(a,b,c) return a..html_modul.ZamianaEncodeTekst(b).."="..html_modul.ZamianaEncodeTekst(c); end; local function OperacjeHtml(adres) adres=mw.ustring.gsub(adres,"^(%??)([^&=]*)=([^&]*)",ParametryEncodeURL); adres=mw.ustring.gsub(adres,"(&)([^&=]*)=([^&]*)",ParametryEncodeURL); return adres; end; return html_modul.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres, -- Funkcja: funkcja_strona; function(strona) strona=html_modul.ZamianaEncodeNaPodstawieWzoruTekstu(strona,"[^/]+"); return strona; end, -- Funkcja: funkcja_parametry; OperacjeHtml, -- Funkcja: funkcja_naglowek; function(naglowek) naglowek=html_modul.ZamianaEncodeTekst(naglowek); return naglowek; end ); </syntaxhighlight> == {{Code|p.ParametryEncodeURL(adres,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.ZamianaEncodeTekst(tekst)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.ParametryEncodeURL(adres,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="//pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obsługa"; local adres2=html_modul.ParametryEncodeURL(adres,true, function(strona) strona=html_modul.ZamianaEncodeNaPodstawieWzoruTekstu(strona,"[^/]+"); return strona; end, function(naglowek) naglowek=html_modul.ZamianaEncodeTekst(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="//pl.wikibooks.org/w/index.php?title=Szablon%3ALink_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}, ale przed nim wywoływana ajest funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a po nim {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryZaawansowanyEncodeURL(adres,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.ParametryZaawansowanyEncodeURL(adres,true, function(strona) strona=mw.uri.decode(strona); strona=html_modul.EncodeSpecjalneZnakiHtml(strona); strona=mw.uri.encode(strona); return strona; end, function(naglowek) naglowek=mw.uri.decode(naglowek); naglowek=html_modul.EncodeSpecjalneZnakiHtml(naglowek); naglowek=mw.uri.encode(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="Szablon%3ALink_wewn%C4%99trzny?action=edit#Obs%C5%82uga%26%2363%3B"; </syntaxhighlight> == {{Code|p.EncodeParametryHtml(parametr,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.EncodeHtml(...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeParametryHtml(parametr,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.EncodeParametryHtml(adres,true, function(strona) strona=html_modul.EncodeHtml(strona); return strona; end, function(naglowek) naglowek=html_modul.EncodeHtml(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="Szablon:Link_wewn%C4%99trzny?action=edit#Obs%C5%82uga%3F"; </syntaxhighlight> == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)|p=Html}}}}, a przed nim wywoływana jest {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a po nim jeżeli jest włączone kodowanie w zmiennej drugiej funkcji, wtedy {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZaawansowanyParametryHtml(adres,z_kodowaniem,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|z_kodowaniem}} - czy ostateczny nagłówek ma być zakodowany, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.EncodeZaawansowanyParametryHtml(adres,true,true, function(strona) strona=mw.uri.decode(strona); strona=html_modul.EncodePodstawoweHtmlTekstu(strona); strona=mw.uri.encode(strona); return strona; end, function(naglowek) naglowek=mw.uri.decode(naglowek); naglowek=html_modul.EncodePodstawoweHtmlTekstu(naglowek); naglowek=mw.uri.encode(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="Szablon%3ALink_wewn%C4%99trzny?action=edit#Obs%C5%82uga%26%2363%3B"; </syntaxhighlight> == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == Funkcja koduje kod {{Strong|HTML}} znaku {{Code|<nowiki>#</nowiki>}}, czyli {{Code|{{Nowiki|&num;}}}}, {{Code|{{Nowiki|&#35;}}}} i {{Code|{{Nowiki|&#x23;}}}}. Te wszystkie kody funkcja zamienia je z każdnych na kod: {{Code|{{Nowiki|&amp;num;}}}}. Funkcja zwraca przetworzony tekst, ze zmienną {{Code|ile}} mówiącej ile jest możliwych kodów na stronie, także z {{Code|ile2}} wskazującej, ile jest kodów na stronie rozwazanego znaku. Funkcja używana, gdy nie chcemy, by dodatkowe znaki {{Code|<nowiki>#</nowiki>}} przeskadzały na rozkład adresu strony na właściwy adres, parametry i nagłówek strony, co po rozkładzie wywoływana jest jego też jego funkcja odwrotna {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}}, a tak powstałe znaki {{Code|{{Nowiki|&#35;}}}} ze wszystkich tych kodów {{Code|<nowiki>#</nowiki>}} według pewnych funkcji modułu {{Code|{{ld2|Html}}}}, że one nie zostaną odkodowane, bo są one pomijane. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeHashKoduHtmlTekstu(tekst)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - tekst do przetworzenia. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Kody do zamienienia local tekst="&num;, &#35; i &#x23;"; -- Przetwarzanie tekstu local tekst2,ile,ile2=html_modul.EncodeHashKoduHtmlTekstu(tekst); </syntaxhighlight> Wynik jest pod zmienną: <syntaxhighlight lang="lua"> -- Wszystkie możliwe warianty funkcja zamieniła na to samo, czyli na: "&amp;num;" kodu HTML "&num;" dla znaku "#"; local tekst2,ile,ile2="&amp;num;, &amp;num; i &amp;num;",3,3; </syntaxhighlight> == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == Jeżeli dokonano zamiany możliwych kodów {{Code|{{Nowiki|&num;}}}}, {{Code|{{Nowiki|&#35;}}}} i {{Code|{{Nowiki|&#x23;}}}} na {{Code|{{Nowiki|&num;num}}}}, wtedy druga zmienna jest większa od zera, wtedy możliwa jest tego zamiana na kod {{Code|{{Nowiki|&#35;}}}} kodu {{Code|{{Nowiki|&num;num}}}}, używając tej funkcji. Funkcja używana, gdy właściwy adres, parametry i nagłówek strony zostały po rozłączeniu na te części z pełnego adresu strony, wraz z innymi funkcjami odkodowującymi znaki niektóre {{Strong|HTML}}, oraz jeżeli ciało jej wersji prostej została wywołana wcześniej. Jest to odwrotność funkcji {{Code|{{sr|#p.EncodeHashKoduHtmlTekstu(tekst)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeHashKoduHtmlTekstu(tekst,ile)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - tekst do przetworzenia, * {{Code|ile}} - {{Code|<nowiki>ile>0</nowiki>}}, jeżeli dokonano możliwych zamian kodów znaku {{Code|<nowiki>#</nowiki>}} na {{Code|{{Nowiki|&num;num}}}}. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Zamienione wcześniej kody: tekstu "&num;, &#35; i &#x23;", kolejno na "&amp;num;"; local tekst="&amp;num;, &amp;num; i &amp;num;"; -- Odkodowanie znaków "&amp;num;" w tekście; local tekst2=html_modul.DecodeHashKoduHtmlTekstu(tekst,3); </syntaxhighlight> Wynik jest ukryty pod zmienną: <syntaxhighlight lang="lua"> local tekst2="&#35;, &#35; i &#35;"; </syntaxhighlight> == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == Jeżeli mamy jakieś kody {{Strong|HTML}}, to aby one nie przeszkadzały w rozkładzie na właściwy adres, parametry i nagłówek strony, to te tam {{Code|<nowiki>#</nowiki>}} należy zamienić na {{Code|{{Nowiki|&num;}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeTempHashKoduHtmlTekstu(tekst)...end; </syntaxhighlight> Parametry: * {{Code|tekst}} - tekst do przetworzenia. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Mamy tutaj kody HTML znaku: "#", czyli: "&#35;" i "&#x23;" oraz jeden od spacji: "&#32;";, a tam "#"zamieniamy na "&num;"; local tekst="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; -- Otrzymamy przetworzony tekst oraz ile uzyskamy znaków z kodem HTML dziesiętnym "ile1" i szesnastkowym "ile2"; local tekst2,ile1,ile2=html_modul.EncodeTempHashKoduHtmlTekstu(tekst); </syntaxhighlight> Wynik tego jest pod zmienną: <syntaxhighlight lang="lua"> local tekst2,ile1,ile2="https://pl.wikibooks.org/wiki/Strona&&num;32;główna&&num;35;&&num;35;&&num;x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony",3,1; </syntaxhighlight> == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == Jeżeli mamy jakieś kody {{Strong|HTML}}, to aby one nie przeszkadzały w rozkładzie na właściwy adres, parametry i nagłówek strony, to te tam {{Code|<nowiki>#</nowiki>}} należy zamienić na {{Code|{{Nowiki|&num;}}}}. One tak zostały zamienione funkcją {{Code|{{sr|#p.EncodeTempHashKoduHtmlTekstu(tekst)|p=Html}}}}. Po rozłożeniu na trzy części pełnego adresu strony, tzn. na właściwy adres, parametry i nagłówek strony, możemy wywołać dla każdej z nich tę funkcję, wykonując operację odwrotną. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeTempHashKoduHtmlTekstu(tekst,ile1,ile2)...end; </syntaxhighlight> Parametry zwykłe funkcji: * {{Code|tekst}} - tekst do przetworzenia i po rozdzieleniu na trzy części, * {{Code|ile1}} - ile jest przetworzonych kodów dziesietnych prez funkcje do rozważanej prostej, * {{Code|ile2}} - ile jest przetworzonych kodów szesnastkowych przez funkcją do rozważanej prostej. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Mamy tutaj kody HTML znaku: "#", czyli: "&&num;35;" i "&&num;x23;" oraz jeden od spacji: "&&num;32;";, a tam "#"zamieniamy na "&num;"; local tekst="https://pl.wikibooks.org/wiki/Strona&&num;32;główna&&num;35;&&num;35;&&num;x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; -- Otrzymamy przetworzony tekst, do którego wsadzamy ile uzyskamy znaków z kodem HTML dziesiętnym "ile1" i szesnastkowym "ile2" w wywołaniu local tekst,ile1,ile2=p.EncodeTempHashKoduHtmlTekstu(tekst); local tekst2=html_modul.EncodeTempHashKoduHtmlTekstu(tekst,3,1); </syntaxhighlight> Wynik tego jest pod zmienną: <syntaxhighlight lang="lua"> local tekst2="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; </syntaxhighlight> == {{Code|p.AdresDomniemanieBezProtokolarnyEncodeURL(adres,...)}} == Funkcja domyślnie koduje adres bezprotokolarny, a z podaniem drugiej wartości {{Code|true}} protokolarny. Funkcja wykorzystuje funkcję {{Code|{{sr|#p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)|p=Html}}}}. A jeżeli druga wartość odpowiada prawdziwości, to korzystamy z {{Code|{{sr|#p["UrlBezProtokołu"](frame)|p=Html}}}} na rozkład na adres bezprotokolarny i protokół. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.AdresDomniemanieBezProtokolarnyEncodeURL(adres,protokolarny)...end; </syntaxhighlight> Parametry: * {{Code|adres}} - adres do zakodowania, * {{Code|protokolarny}} - czy ma rozkładać adres na nazwę strony i protokół. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Adres protokonalny; local adres11="https://pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; local adres12=html_modul.AdresDomniemanieBezProtokolarnyEncodeURL(adres11,true); -- Adres bezprotokonalny; local adres21="//pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; local adres22=html_modul.AdresDomniemanieBezProtokolarnyEncodeURL(adres21,false); </syntaxhighlight> Wynik wartości {{Code|adres12}} i {{Code|adres12}} jest: <syntaxhighlight lang="lua"> -- Zakodowany adres z protokołem local adres12="https://pl.wikibooks.org/wiki/Strona_g%C5%82%C3%B3wna?action=edit&section=2#Nag%C5%82%C3%B3wek%20strony"; -- Zakodowany adres bez protokołu local adres22="//pl.wikibooks.org/wiki/Strona_g%C5%82%C3%B3wna?action=edit&section=2#Nag%C5%82%C3%B3wek%20strony"; </syntaxhighlight> == {{Code|p.UriEncode(frame)}} == Funkcja do kodowania adresów tylko z protokołem, wartości bez protokołu nie obsługuje. Wykorzystuje {{Code|{{sr|#p.AdresDomniemanieBezProtokolarnyEncodeURL(adres,...)|p=Html}}}}. Do wyszukiwania adresów jest brana funkcja {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.UriEncode(frame)...end; </syntaxhighlight> Parametry tablicy ramki tablicy transportu: * {{Code|html}} - adres z protokołem strony. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|html}}. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Adres protokonalny; local adres="https://pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; -- Równoważnie: local adres2=html_modul.UriEncode{html=adres,}; local adres2=html_modul.UriEncode(adres); </syntaxhighlight> Wynik jest w zmiennej: <syntaxhighlight lang="lua"> local adres2="https://pl.wikibooks.org/wiki/Strona_g%C5%82%C3%B3wna?action=edit&section=2#Nag%C5%82%C3%B3wek%20strony"; </syntaxhighlight> == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == Funkcja blokuje odkodowywanie możliwych kodów {{Strong|HTML}} znaku {{Code|<nowiki>#</nowiki>}}, w tym celu wywoływana jest funkcja: {{Code|{{sr|#p.KodowanieOmijanieFunkcyjne(html,...)|p=Html}}}}, do omijania tego znaku, funkcja omija tylko znaki zapisane w kodach {{Strong|HTML}}, tzn. {{Code|{{Nowiki|&#35}}}}, w tym celu wszystkie kody tego znaku zamieniamy na jeden, przed wywołaniem tej funkcji, funkcjami: {{Code|{{sr|#p.EncodeHashKoduHtmlTekstu(tekst)|p=Html}}}} i {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}}. Ta funkcja w pierwszym kroku, w nim we wspomnianej funkcji wywołanej w funkcji anonimowej, wywołuje funkcję dekodujące znaki, czyli: {{Code|{{sr|#p.DecodeKoduHTMLZnaku(tekst)|p=Html}}}}, do odkodowania kodów, {{Strong|HTML}}, dziesiętnych, szesnastkowych i literowych. Na samym końcu kodowane są specjalne znaki na podstawie: {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}, na kody {{Strong|HTML}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)...end; </syntaxhighlight> Parametry: * {{Code|elementy_adresu_strony}} - funkcja do podstawowego kodowania adresu. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.EncodePodstawoweHtmlTekstu(adres); </syntaxhighlight> Wartość zmiennej jest ukryta pod: <syntaxhighlight lang="lua"> local adres2="Szablon:Link_wewnętrzny&#63;action&#61;edit&#35;Obsługa&#63;"; </syntaxhighlight> == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == Gdy mamy problem (przypadek) z parametrami adresu strony,wtedy do kodowania wywoływana jest funkcja {{Code|{{sr|#p.EncodeZaawansowanyParametryHtml(adres,...)|p=Html}}}}, a gdy posługujemy się właściwym adresem strony lub nagłówkiem, wtedy dekodujemy '''URL''' funkcją {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, następnie {{Code|{{sr|#p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)|p=Html}}}}, i jeżeli mały włączone kodowanie, następnie {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeElementyAdresuStrony(elementy_adresu_strony,czy_parametry_strony,z_kodowaniem)...end; </syntaxhighlight> Parametry: * {{Code|elementy_adresu_strony}} - element adresu strony, * {{Code|czy_parametry_strony}} - czy parametry strony rozważać, jako że wtedy jest taki adres jako parametry, * {{Code|z_kodowaniem}} - czy jest włączone kodowanie funkcji po odkodowaniu i pewnych operacjach w tej funkcji. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local elementy_adresu_strony="Obsługa?"; local elementy_adresu_strony2=html_modul.EncodeElementyAdresuStrony(elementy_adresu_strony,false,true); </syntaxhighlight> Wartość zmiennej jest ukryta pod: <syntaxhighlight lang="lua"> local elementy_adresu_strony2="Obs%C5%82uga%26%2363%3B"; </syntaxhighlight> == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == Funkcja korzysta do dekodowania na samym początku '''URL''' {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a na końcu {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}, jeżeli jest włączone kodowanie, między czasie korzysta z {{Code|{{sr|#p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)|p=Html}}}}. Główny elementem funkcyjnym jest {{Code|{{sr|#p.EncodeZaawansowanyParametryHtml(adres,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.AdresProjektuEncodeHtml(frame,z_kodowaniem,protokolarny)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|z_kodowaniem}} - czy końcowo kodować, * {{Code|protokolarny}} - czy uważać przy kodowaniu na protokoły pełnych adresów stron. Parametry tablicy ramki tabeli transportu: * {{Code|html}} - adres do kodowania, * {{Code|encode}} - czy kodować. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|html}}. Przykłady: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="https://pl.wikibooks.org/wiki/Strona_&główna?&?action=edit&section=2&title=Nazwa strony szablonu: {{!}}#Nagłówek strony"; local adres2=html_modul.AdresProjektuEncodeHtml(adres,false,true); local adres3=html_modul.AdresProjektuEncodeHtml(adres,true,true); </syntaxhighlight> Wartość zmiennej jest ukryta pod: <syntaxhighlight lang="lua"> local adres2="https://pl.wikibooks.org/wiki/Strona_&#38;główna&#63;&#38;?action=edit&section=2&title=Nazwa strony szablonu: &#123;&#123;!&#125;&#125;#Nagłówek strony"; local adres3="https://pl.wikibooks.org/wiki/Strona_%26%2338%3Bg%C5%82%C3%B3wna%26%2363%3B%26%2338%3B?action=edit&section=2&title=Nazwa%20strony%20szablonu%3A%20%26%23123%3B%26%23123%3B%21%26%23125%3B%26%23125%3B#Nag%C5%82%C3%B3wek%20strony"; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> ijga5qj7qciqq0pf5yckdyvm52zhck0 541353 541344 2026-04-30T08:03:56Z Persino 2851 541353 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ę dziesiętnymi, szesnastkowymi i literowymi kodami {{Strong|HTML}} i zamieniania ich na odpowiednie znaki, zamieniania znaków na ich kody dziesiętne, 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 łączenie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p.KodowanieOmijanieFunkcyjne(html,...)}} == Funkcja wywołuje funkcję modułu {{Code|{{ld2|Szeregi}}}} zwaną {{Code|{{sr|#p.SzeregiOmijanieFunkcyjne(tekst,...)|p=Szeregi}}}}. Domyślnym wzorem jest {{Code|<nowiki>&([^&;%s]+);</nowiki>}}, ale można go zmienić na inny. Drugą funkcją podawaną do tej funkcji jest domyślnym obiektem funkcyjnym anonimowym, który nie podaje się do funkcji w nagłówku: <syntaxhighlight lang="lua"> function(kod) return "&"..kod..";"; end </syntaxhighlight> Gdzie {{Code|kod}} jest elementem przechwytywanym kodu {{Strong|HTML}}, który jest określony poprzez nawiasy okrągłe we wzorze podawanym jako argument lub, jeśli jest on równy {{Code|nil}}, wtedy we wzorze domyślnym, który w takim razie jest rozpatrywany. Funkcja służy do omijania wszystkich kodów {{Strong|HTML}} lub tylko niektórych i robienia na nich operacji za pomocą funkcji podawanej jako ostatni parametr. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.KodowanieOmijanieFunkcyjne(html,normalnie,wzor,funkcja)...end; </syntaxhighlight> Parametry funkcji: * {{Code|html}} - ciąg do przetworzenia, w częściach bez parametrów omijanych, * {{Code|normalnie}} - czy ma przetwarzać tekst pomijając, w przeciwnym wypadku tak nie robi, * {{Code|wzor}} - wzór do elementów pomijanych, wzór może mieć tylko jeden element przechwytywany, * {{Code|funkcja}} - funkcja robiąca operacje na przetworzonych subciągach bez elementów pomijanych. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest tekst wywołania: \"&#35;\""; local tekst2=html_modul.KodowanieOmijanieFunkcyjne(tekst,true,"&(#35);",function(tekst) return mw.uri.encode(tekst); end); </syntaxhighlight> Wynik jest: <syntaxhighlight lang="lua"> local tekst2="Oto+jest+tekst+wywo%C5%82ania%3A+%22&#35;%22"; </syntaxhighlight> == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody dziesiętne {{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 się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <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 się tekst do zamiany kodów {{Strong|HTML}}, dziesiętnych i szesnastkowych, na znaki. 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w tekście (w zawartości pomiędzy tagami tagu {{Tag|nowiki}}, by potem je tam umieścić, by pierwotna zawartość równała się tekstowi wyświetlanemu (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}})), wikikodu na kody dziesiętne {{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 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 się tekst do zamiany znaków, z zestawu znaków specjalnych wskazanych w funkcji, występujących w tagach języka '''HTML''' do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <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 się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <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,normalnie)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}. Parametry ramki funkcji tablicy transportu: * {{Code|html}} - zmienna, pod którym wyszukuje się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego kodu {{Strong|HTML}}, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}, jeżeli jej wartość odpowiada wartości logicznej {{Code|false}}, wtedy liczy się jej wersja parametrowa funkcji. 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|html}}. 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> Wyniki działania: <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 samym początku, to jest określane 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 się tekst do zamiany z podanego zestawu znaków pierwszych znaków listy, mechanizmu {{Strong|MediaWiki}}, do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <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 zamienia znaki {{Code|<nowiki>=%?&</nowiki>}} na kody dziesiętne {{Strong|HTML}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Funkcja potrafi opcjonalnie omijać kody {{Strong|HTML}}, w zależności od podanego drugiego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame,normalnie)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}. Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego kodu {{Strong|HTML}}, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}, jeżeli jej wartość odpowiada wartości logicznej {{Code|false}}, wtedy liczy się jej wersja parametrowa funkcji. 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <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 się tekst do zamiany znaków przypisania {{Code|{{=}}}} do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <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 dziesiętne {{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 się tekst do zamiany ze znaku dwukropka do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <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 dziesiętny {{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 dziesiętny {{Strong|HTML}}, * {{Code|2}} - czy znak {{Code|{{Nowiki|&}}}} ma być zamieniany na {{Code|{{Nowiki|&amp;}}}}, a znak {{Code|<nowiki>#</nowiki>}} na {{Code|{{Nowiki|&num;}}}}. 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}}. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}. 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> Wyniki działania: <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 === Zamienia ściśle określone znaki (zestaw kodów znajduje się na stronie: {{Code|{{ls2|KodyHTMLZnakówWikiCiągu/opis}}}}) na kody dziesiętne {{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["KodyHTMLZnakówWikiCiągu"](frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|1}} - ciąg, pod którym są możliwe ściśle określone znaki są zamieniane na kod {{Strong|HTML}}, ciąg ten jest ze znakami wiki w UTF8, * {{Code|2}} - czy znak {{Code|{{Nowiki|&}}}} ma być zamieniany na {{Code|{{Nowiki|&amp;}}}} i {{Code|<nowiki>#</nowiki>}} na {{Code|{{Nowiki|&num;}}}}. 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}}. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="k{{s"; -- Równoważne: local tekst2=html_modul["KodyHTMLZnakówWikiCiągu"]{[1]=tekst,}; -- Równoważne: local tekst2=html_modul["KodyHTMLZnakówWikiCiągu"]{args={[1]=tekst,},}; local tekst2=html_modul["KodyHTMLZnakówWikiCiągu"](znak); -- Równoważne: local tekst3=html_modul["KodyHTMLZnakówWikiCiągu"]{[1]=tekst,[1]="tak",}; local tekst3=html_modul["KodyHTMLZnakówWikiCiągu"]{args={[1]=tekst,[2]="tak",},}; </syntaxhighlight> Wyniki działania: <syntaxhighlight lang="lua"> local tekst2="k&#123;&#123;s"; local tekst3="k&amp;&num;123;&amp;&num;123;s"; </syntaxhighlight> Szablonowo taką zamianę możemy napisać: * {{Code|{{s|KodyHTMLZnakówWikiCiągu|k{{s|((}}s}}}} → {{Tt|{{KodyHTMLZnakówWikiCiągu|k{{((}}s}}}} * {{Code|{{s|Nowiki|{{s|KodyHTMLZnakówWikiCiągu|k{{s|((}}s}}}}}} → {{Tt|{{Nowiki|{{KodyHTMLZnakówWikiCiągu|k{{((}}s}}}}}} * {{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}}}}}} Równie dobrze możemy napisać takie wywołania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="mediawiki"> <!-- Wyświetla wynik: "k&#123;&#123;s"; --> {{#invoke:Html|KodyHTMLZnakówWikiCiągu|k{{((}}s|wyspecjalizowana=tak}} <!-- Wyświetla wynik: "k&amp;&num;123;&amp;&num;123;s"; --> {{#invoke:Html|KodyHTMLZnakówWikiCiągu|k{{((}}s|tak|wyspecjalizowana=tak}} </syntaxhighlight> == {{Code|p.EncodeId(...)}} == Funkcja służy do opcjonalnego dekodowania ciągów znakowych według {{Code|{{sr|#p.DecodeHtml(...)|p=Html}}}}, i cały ciąg od specjalnych znaków jest transformowany przez funkcję {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeId(id,bez_transformacji)...end; </syntaxhighlight> Parametry nieramkowe normalne funkcji: * {{Code|id}} - ciąg do przeinaczenia, * {{Code|bez_transformacji}} - gdy nie {{Code|false}} lub {{Code|nil}}, funkcja nie transformuje na podstawie: {{Code|{{sr|#p.DecodeHtml(...)|p=Html}}}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local id="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; local id2=html_modul.EncodeId(id,false); </syntaxhighlight> Wynikiem tego: <syntaxhighlight lang="lua"> local id2="https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link wewnętrzny&#38;action&#61;edit&#35;Obsługa"; </syntaxhighlight> Gdy: {{Code|bez_transformacji{{=}}true}}, funkcja działa jak: {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}, ale wtedy {{Code|frame{{=}}id}}, a przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local id="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; local id2=html_modul.EncodeId(id,true); </syntaxhighlight> Wynikiem działania jest wartość ostatniej zmiennej: <syntaxhighlight lang="lua"> local id2="https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link_wewn%C4%99trzny&#38;action&#61;edit&#35;Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == Usuwa z tekstu znak numer {{Code|8206}} zestawu {{lpg|Unicode}}, który można napisać, jeśli jest widoczny na ekranie komputera {{Code|&#8206;}} (znak {{Code|{{Nowiki|&#8206;}}}}). Ten znak oczywiście Unicode jest w grupie zwanej invisible Unicode characters i służy do ustawiania kierunku tekstu lewo do prawo. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)...end; </syntaxhighlight> Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tutaj jest zakodowany znak HTML, o kodzie dziesiętnym "&#8206;", składający się z trzech bajtów: "&#226;", "&#128;" i "&#142;"; local tekst="Oto jest znak: &#8206;."; -- Zamiana tego kodu na znak; tekst=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); -- Tekst bez tego znaku, bo on został w tym wywołaniu całkowicie usunięty; tekst=html_modul.UsuwanieSpecjalnychNieschematycznychSymboli(tekst); </syntaxhighlight> Wynikiem tego kodu jest wartość ukryta pod zmienną: <syntaxhighlight lang="lua"> local tekst="Oto jest znak: ."; </syntaxhighlight> == {{Code|p.EncodeWiki(...)}} == Funkcja transformuje kody {{Strong|HTML}} do znaku przy pomocy funkcji {{Code|{{sr|#p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)|p=Html}}}}, usuwa nieschematyczne znaki o kodzie {{Code|{{Nowiki|&#8206;}}}} dzięki funkcji: {{Code|{{sr|#p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)|p=Html}}}}, następnie opcjonalnie usuwa znaki będące odstępami lub dolnymi myślnikami z początku i końca tekstu, i zamienia wewnątrz znaki kolejne odstępów lub dolnych myślników na jeden dolny myślnik na podstawie {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, dalej zaraz funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.text.encode|n=mw.text.encode}}}} koduje tekst, tą funkcją {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeWiki(parametr,czy_nie_odstepy)...end; </syntaxhighlight> Parametry funkcji: * {{Code|parametr}} - tekst, który chcemy zakodować, * {{Code|czy_nie_odstepy}} - czy nie ma na tekst podziałać funkcją {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local parametr="__Oto jest znak: \"&#8206;\" i inne_znaki_w_URL: \"https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link wewnętrzny&#38;action&#61;edit&#35;Obsługa;\"__"; local parametr2=html_modul.EncodeWiki(parametr,false); local parametr3=html_modul.EncodeWiki(parametr,true); </syntaxhighlight> Wynikiem działania tej funkcji jest parametr {{Code|parametr2}} i {{Code|parametr3}}, którego wartości: <syntaxhighlight lang="lua"> local parametr2="Oto_jest_znak:_&quot;&quot;_i_inne_znaki_w_URL:_&quot;https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewnętrzny&amp;action=edit#Obsługa;&quot;"; local parametr3="__Oto jest znak: &quot;&quot; i inne_znaki_w_URL: &quot;https://pl.wikibooks.org/w/index.php?title=Szablon:Link wewnętrzny&amp;action=edit#Obsługa;&quot;__"; </syntaxhighlight> == {{Code|p.DecodeWiki(...)}} == Funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.text.decode|n=mw.text.decode}}}} dekoduje tekst, tą funkcją {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Następnie usuwa nieschematyczne symbole: {{Code|{{Nowiki|&#8206;}}}}, dzięki funkcji: {{Code|{{sr|#p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)|p=Html}}}}, następnie działa opcjonalnie funkcją, która usuwa znaki będące odstępami lub dolnymi myślnikami z początku i końca tekstu oraz zamieniając wewnątrz znaki kolejne odstępów lub dolnych myślników na jedną dolną spacją na podstawie {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeWiki(parametr,czy_nie_odstepy)...end; </syntaxhighlight> Parametry funkcji: * {{Code|parametr}} - tekst, który chcemy odkodować, * {{Code|czy_nie_odstepy}} - czy nie ma na tekst podziałać funkcją {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local parametr="__Oto jest znak: &quot;&#8206;&quot; i inne_znaki_w_URL: &quot;https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link wewnętrzny&#38;action&#61;edit&#35;Obsługa;&quot;__"; local parametr2=html_modul.DecodeWiki(parametr,false); local parametr3=html_modul.DecodeWiki(parametr,true); </syntaxhighlight> Wynikiem działania tej funkcji jest parametr {{Code|parametr2}} i {{Code|parametr3}}, którego wartość: <syntaxhighlight lang="lua"> local parametr2="Oto jest znak: \"\" i inne znaki w URL: \"https://pl.wikibooks.org/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa;\""; local parametr3="__Oto jest znak: \"\" i inne_znaki_w_URL: \"https://pl.wikibooks.org/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa;\"__"; </syntaxhighlight> == {{Code|p.IsEncodedHtml(...)}} == Funkcja sprawdza, czy można uznać, że funkcja jest zakodowana, tzn. dalej nie warto jej kodować przy pomocy funkcji: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}, czy dekodować, bo już można uznać ją za odkodowaną, czyli nie trzeba stosować funkcji: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}. Funkcja zwraca wartość {{Code|true}}, jak można uznać tekst za zakodowany i {{Code|false}}, gdy jest niezakodowana. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IsEncodedHtml(parametr,encode,encode_real)..end; </syntaxhighlight> Parametry funkcji: * {{Code|parametr}} - parametr do sprawdzenia - wymagany, * {{Code|encode}} - gdy jest sprawdzana tylko obecność znaku {{Code|%}}, * {{Code|encode_real}} - gdy jest sprawdzana, nie tylko obecność znaku {{Code|%}}, też czy {{Code|parametr}} jest ciągiem podporządkowanym wyrażeniu regularnemu {{Code|<nowiki>^[%w%p%s]*$</nowiki>}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Pierwszy przykład: local parametr1="abc?edit=action"; -- Wartość zmiennej obliczona jest: czy_tak1=true, czyli parametr1 można uznać za zakodowany; local czy_tak1=html_modul.IsEncodedHtml(parametr1,true,false); -- Drugi przykład: local parametr2="a%YTbc?edit=action;"; -- Wartość zmiennej obliczona jest: czy_tak2=false; czyli parametr2można uznać, że nie jest zakodowany; local czy_tak2=html_modul.IsEncodedHtml(parametr2,true,false); </syntaxhighlight> == {{Code|p.EncodeHtml(...)}} == Funkcja sprawdza, czy podany parametr do transformacji uznać za zakodowany, jeżeli za taki zostanie uznany, wtedy zostanie, to on zostanie potraktowany funkcją {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}, a jeżeli nie to zostanie wywołana funkcja: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}} (z parametrem "WIKI"). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeHtml(parametr,encode,encode_real,czy_nie_odstepy)...end; </syntaxhighlight> Parametry funkcji: * {{Code|parametr}} - parametr do transformacji kodowania, * {{Code|encode}} i {{Code|encode_real}} - te parametry to samo oznaczają, co w funkcji: {{Code|{{sr|#p.IsEncodedHtml(...)|p=Html}}}}, * {{Code|czy_nie_odstepy}} - to samo oznacza, co w funkcji {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}. {{Hr}} Przykłady pierwszy - podany tekst już zakodowany: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst do zakodowania; local parametr="abc___&#63;action&#61;edit&#38;section&#61;21&#35;nagłówek"; -- Tekst zostanie uznany za zakodowany, sprawdzane, czy on ma znaki "%", czyli on tego nie posiada; local parametr2=html_modul.EncodeHtml(parametr,true,false,false); </syntaxhighlight> Wynik zmiennej {{Code|parametr2}} jest ukryty pod jego wartością: <syntaxhighlight lang="lua"> -- Widzimy, że podwojone myślniki dolne zostały zamienione na pojedyncze, kody HTML zostały zamienione na znaki, a znak "&#38;", czyli "&" został zamieniony na "&amp;"; local parametr2="abc_?action=edit&amp;section=21#nagłówek"; </syntaxhighlight> {{Hr}} Przykłady drugi - podany tekst jeszcze nie zakodowany: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst do zakodowania; local parametr="a%YTbc___?action=edit;"; -- Tekst zostanie uznany za niezakodowany, czy on ma znaki "%", czyli on to posiada; local parametr2=html_modul.EncodeHtml(parametr,true,false,false); </syntaxhighlight> Wynik zmiennej {{Code|parametr2}} jest ukryty pod jego wartością: <syntaxhighlight lang="lua"> -- Widzimy, że znak "%" został zakodowany funkcją mw.uri.encode, podobnie tą funkcją zostały zakodowane: "?" i "="; local parametr2="a%25YTbc___%3Faction%3Dedit;"; </syntaxhighlight> == {{Code|p.DecodeHtml(...)}} == Funkcja sprawdza, czy {{Code|parametr}}, czy można uznać za zakodowany, a jeżeli można, to on zostanie w zależnosci od parametru {{Code|spacje}}, to odpowiednio zostanie wywołana {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a następnie w zależności od parametru (opis w parametrach) zostanie wywołana odpowiednia funkcja odkoduwująca lub kodująca {{Code|wiki}}. Jeżeli ciąg rzeczywiście jest uznany za niezakodowany jest podobnie odpowiednio z tylko z wywołaniami funkcji {{Code|wiki}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeHtml(parametr,spacje,encode,encode_real,czy_nie_odstepy)...end; </syntaxhighlight> Parametry funkcji: * {{Code|parametr}} - parametr do odkodowania, * {{Code|spacje}} - gdy parametr odpowiada {{Code|true}} używa funkcji {{Code|{{sr|#p.DecodeWiki(...)|p=Html}}}}, w przeciwnym wypadku: {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}, ale wpierw musi zostać wywołana funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}} w przypadku, gdy ciąg zostanie uznany za zakodowany, jak to robi funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}, * {{Code|encode}} i {{Code|encode_real}} - te parametry są używane przez funkcje {{Code|{{sr|#p.IsEncodedHtml(...)|p=Html}}}}, * {{Code|czy_nie_odstepy}} - gdy ciąg został uznany za niezakodowany, wtedy to jest drugi parametr funkcji: {{Code|{{sr|#p.DecodeWiki(...)|p=Html}}}} lub {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Parametr zawiera znaki zakodowane funkcją mw.uri.encode i kody HTML znaków; local parametr="a%25YTbc___%3Faction%3Dedit&#38;section&#61;23;"; local parametr2=html_modul.DecodeHtml(parametr,true); </syntaxhighlight> Wynik funkcji jest ukryty pod adresem: <syntaxhighlight lang="lua"> -- Funkcja została uznana za zakodowaną i odkodowano ją funkcją mw.uri.decode, dalej dwa dolne myślniki zostały zamienione na jedną spację, a kody HTML zostały zamienione na odpowiednie znaki; local parametr2="a%YTbc ?action=edit&section=23;"; </syntaxhighlight> == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == Szuka atrybutów w cudzysłowach i w nich elementy {{Code|<nowiki><>&</nowiki>}} zamienia na kody dziesiętne {{Strong|HTML}}, a także znaki lewego ukośnika {{Code|<nowiki>\</nowiki>}} też na to. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)...end; </syntaxhighlight> Parametry funkcji: * {{Code|znacznik}} - atrybut do przetwarzania, aby w nim zamienić niektóre znaki, które przeszkadzają w analizie na kody, o odpowiednim formacie, {{Strong|HTML}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"Znaki<>\\\"\">To jest zawartość</span>"; local tekst2=html_modul.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(tekst); </syntaxhighlight> Wartość tej zmiennej jest ukryta pod {{Code|tekst2}}: <syntaxhighlight lang="lua"> -- Widzimy, że został sam jeden atrybut ze znakami HTML wewnątrz; local tekst2="<span id=\"Znaki&lt;&gt;&#92;&#34;\">To jest zawartość</span>"; </syntaxhighlight> == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == Zamienia kody {{Strong|HTML}}, tzn.: {{Code|{{Nowiki|&lt;}}}}, {{Code|{{Nowiki|&gt;}}}} i {{Code|{{Nowiki|&amp;}}}}, na odpowiednio znaki, a także elementy {{Code|{{Nowiki|&#92;&#34;}}}} na {{Code|<nowiki>\"</nowiki>}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)...end; </syntaxhighlight> Parametry funkcji: * {{Code|value}} - parametr do transformacji niektórych kodów {{Strong|HTML}} na znaki. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="&lt;a href=\"/wiki/Strona?tytan1=1&amp;tytan2=2\" id=\"Strona:&#92;&#34;nazwa&#92;&#34;\"&gt;Zawartość znacznika&lt;/a&gt;"; local tekst2=html_modul.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(tekst); </syntaxhighlight> Otrzymana zawartość jest pod {{Code|tekst2}}: <syntaxhighlight lang="lua"> -- Widzimy, że kody odpowiednie HTML, tzn.: "&lt;", "&gt;" i "&amp;" zostały zamienione na odpowwiednie znaki; local tekst2="<a href=\"/wiki/Strona?tytan1=1&tytan2=2\" id=\"Strona:\\\"nazwa\\\"\">Zawartość znacznika</a>"; </syntaxhighlight> == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == Funkcja wydziela nagłówek z adresu strony, funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NagłówekStronyAdresu"]=function(frame,czy_nie_dolne_myslniki,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_nie_dolne_myslniki}} - gdy {{Code|true}}, jeśli w nagłówku nie ma prawa być dolnych myślników, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Funkcja usuwa zbędne odstępy i dolne myślniki na końcach nagłówka, i powtarzające się znaki będące odstępami lub dolnymi myślnikami są zastępowane przez jedną spację, gdy {{Code|czy_nie_dolne_myslniki}} równa jest wartości odpowiadającej {{Code|true}}, w przeciwnym wypadku zamieniana jest ona na jeden dolny myślnik. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_nie_dolne_myslniki}} (parametr funkcji), {{Code|2}} lub {{Code|z nie dolnymi z myślnikami}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local naglowek=html_modul["NagłówekStronyAdresu"](strona,true,tabela_nazw_adresu); local naglowek=html_modul["NagłówekStronyAdresu"]({strona=strona,["z nie dolnymi z myślnikami"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony, nagłówek usuwając z niego myślniki dolne i trimując zawartość; local naglowek="Nagłówek strony"; </syntaxhighlight> == {{Code|p["ParametryStronyAdresu"](frame,...)}} == Funkcja wydziela parametry z adresu strony, funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ParametryStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma suwać zbędne odstępy i dolne myślniki z parametrów adresu, wydzieloną z pełnego adresu strony, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local parametry=html_modul["ParametryStronyAdresu"](strona,true,tabela_nazw_adresu); local parametry=html_modul["ParametryStronyAdresu"]({strona=strona,["czy naprawiać"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony parametry, usuwając z niego zbędne odstępy i myślniki dolne; local parametry="action=edit&section=2"; </syntaxhighlight> == {{Code|p["NazwaStronyAdresu"](frame,...)}} == Funkcja wydziela nazwę strony z adresu strony, funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwaStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma suwać zbędne odstępy i dolne myślniki z adresu strony, bez parametrów i nagłówka, wydzieloną z pełnego adresu strony, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local parametry=html_modul["NazwaStronyAdresu"](strona,true,tabela_nazw_adresu); local nazwa_strony=html_modul["NazwaStronyAdresu"]({strona=strona,["czy naprawiać"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony nazwę strony adresu, usuwając z niego zbędne odstępy i myślniki dolne; local nazwa_strony="https://pl.wikibooks.org/wiki/Strona_główna"; </syntaxhighlight> == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == Funkcja wydziela nazwę strony z parametrów adresu strony. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["NazwaStronyZParametrówStronyAdresu"]=function(frame,czy_naprawiaj)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma suwać zbędne odstępy i dolne myślniki z parametrów strony adresu, i czy zamieniać je na pojedyncze spacje wewnątrz nazwy artykułu wydzieloną z parametrów strony. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}} lub {{Code|parametry}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}} lub {{Code|parametry}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="title=Strona ___ główna & action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; -- Równoważne: local parametry=html_modul["NazwaStronyZParametrówStronyAdresu"](strona,true); local nazwa_strony=html_modul["NazwaStronyZParametrówStronyAdresu"]({parametry=strona,["czy naprawiać"]=true,},nil); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony nazwę artykułu, usuwając z niego zbędne odstępy i myślniki dolne; local nazwa_strony="Strona główna"; </syntaxhighlight> == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == Funkcja poprawia pełny adres strony, rozdzielając ją na części, a później łącząc. Funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma naprawiać pełny adres strony, działając w sposób specyficzny w zależności od funkcji, która operuje na jej częściach, wykorzystując funkcje, które są napisane w linii zaraz poniżej, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykład: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local parametry=html_modul["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](strona,true,tabela_nazw_adresu); local adres=html_modul["PoprawAdresNagłówkaOrazParametrówStronyAdresu"]({strona=strona,["czy naprawiać"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość pełnego adresu strony poprawiona jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z pełnego adresu strony adres, parametry i nagłówek, naprawione i złączone ze sobą w pełny poprawiony adres; local adres="https://pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; </syntaxhighlight> == {{Code|p.URLStrona(frame)}} == Funkcja z adresu '''URL''' wydziela nazwę serwera i nazwę strony. On nie może zawierać w sobie protokołu, tylko musi zaczynać od {{Code|<nowiki>//</nowiki>}}. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.URLStrona(frame)...end; </syntaxhighlight> Parametry ramki: * {{Code|1}} lub {{Code|url}} - adres strony, * {{Code|2}} lub {{Code|ukośnik}} - czy do nazwy strony ma wliczać ukośnik. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"): local url="//pl.wikibooks.org/wiki/Strona_artykułu"; local serwer,nazwa=html_modul.URLStrona{url=url,["ukośnik"]=true,}; </syntaxhighlight> Wartości zmiennych kryją się pod: <syntaxhighlight lang="lua"> -- Widzimy, że nazwa serwera jest bez prawych ukośników; local serwer="pl.wikibooks.org"; -- Nazwa strony zaczyna się bez ukośnika, bo powiedzieliśmy funkcji, by nie brał prawych ukośników, które są na początku nazwy strony, bez nazwy serwera i protokołu, ale w sobie może mieć on, ale nie musi; local nazwa="wiki/Strona_artykułu"; -- Gdyby było ["ukośnik"]=false, to wtedy otrzymalibyśmy inny wynik, czyli: local nazwa="/wiki/Strona_artykułu"; </syntaxhighlight> == {{Code|p["UrlBezProtokołu"](frame)}} == Funkcja adresowi z protokołem usuwa to właśnie, a jak podamy adres „mail”, to podaje nazwę tego adresu, bez niego. Drugą zwracaną nazwą jest nazwa protokołu,a jak się nie da go wyznaczyć, to funkcja zwraca wartość {{Code|nil}}. Trzecia wartość, to numer sposoby, a jeżeli żaden sposób nie pasuje, to ta wartość jest {{Code|-1}}, a gdy adres mail {{Code|1}}, dla adresu z protokołem {{Code|2}}, a dla adresu bez protokołu {{Code|3}}. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UrlBezProtokołu"]=function(frame)...end; </syntaxhighlight> Parametry ramki: * {{Code|1}} lub {{Code|url}} - adres strony, ewentualnie z opcjonalnym protokołem. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}} lub {{Code|url}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local mail="użytkownik@skrzynka.org"; -- Równoważnie: local adres1,protokol1,sposob1=html_modul["UrlBezProtokołu"](mail); local adres1,protokol1,sposob1=html_modul["UrlBezProtokołu"]{url=mail,}; --- local url="https://pl.wikibooks.org/wiki/Strona"; -- Równoważnie: local adres2,protokol2,sposob2=html_modul["UrlBezProtokołu"](url); local adres2,protokol2,sposob2=html_modul["UrlBezProtokołu"]{url=url,}; --- local url="//pl.wikibooks.org/wiki/Strona"; -- Równoważnie: local adres3,protokol3,sposob3=html_modul["UrlBezProtokołu"](url); local adres3,protokol3,sposob3=html_modul["UrlBezProtokołu"]{url=url,}; --- local url="pl.wikibooks.org/wiki/Strona"; -- Równoważnie: local adres4,protokol4,sposob4=html_modul["UrlBezProtokołu"](url); local adres4,protokol4,sposob4=html_modul["UrlBezProtokołu"]{url=url,}; </syntaxhighlight> Wyniki otrzymane z powyższych przykładów są: <syntaxhighlight lang="lua"> local adres1,protokol1,sposob1="//skrzynka.org","mail",1; local adres2,protokol2,sposob2="//pl.wikibooks.org/wiki/Strona","https",2; local adres3,protokol3,sposob3="//pl.wikibooks.org/wiki/Strona",nil,3; local adres4,protokol4,sposob4="//pl.wikibooks.org/wiki/Strona",nil,-1; </syntaxhighlight> == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == Zamienia kody {{Strong|HTML}}, tzn. literowe (ogólny wzór {{Code|<nowiki>&(%a+);</nowiki>}}), dziesiętne (ogólny wzór {{Code|<nowiki>&#(%d+);</nowiki>}}) i szesnastkowe (ogólny wzór {{Code|<nowiki>&#x(%x+);</nowiki>}}) na odpowiednie znaki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeKoduHTMLZnaku(tekst)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tekst}} - tekst do zamienienia z dziesiętnymi, szesnastkowymi i literowymi kodami {{Strong|HTML}} na odpowiednie znaki. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst z kodami HTML: literowymi, dziesiętnymi i szesnastkowymi; local tekst="Oto jest link: &#x5B;&#x5B;Strona&#124;Nazwa linku&#93;&#x5D;, a w nim spacje niełamliwe&nbsp;i inne znaki: z alfabetu greckiego jak: &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;"; -- Wywołanie funkcji odkodujący kody HTML; local tekst2=html_modul.DecodeKoduHTMLZnaku(tekst); </syntaxhighlight> Otrzymany wynik jest pod zmienną: <syntaxhighlight lang="lua"> -- Widzimy, że tekst został zdekodowany ze znaków HTML; local tekst2="Oto jest link: [[Strona|Nazwa linku]], a w nim spacje niełamliwe i inne znaki: z alfabetu greckiego jak: αΑβΒγΓδΔεΕζΖηΗθΘιΙκΚλΛμΜνΝξΞοΟπΠρΡσΣτΤυΥφΦχΧψΨωΩ"; </syntaxhighlight> == {{Code|p.ZamianaEncodeTekst(tekst)}} == Adres strony dekoduje funkcją: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, następnie koduje, jeszcze więcej niż było na samym początku, według: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaEncodeTekst(tekst)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tekst}} - tekst do odkodowania i zakodowania jeszcze więcej niż było na początku zakodowane. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; local tekst2=html_modul.ZamianaEncodeTekst(tekst); </syntaxhighlight> Wynikiem funkcji, co kryje się pod zmienną {{Code|tekst2}}: <syntaxhighlight lang="lua"> local tekst2="https%3A%2F%2Fpl.wikibooks.org%2Fw%2Findex.php%3Ftitle%3DSzablon%3ALink_wewn%C4%99trzny%26action%3Dedit%23Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == Funkcja wyszukuje tekst do zamiany i działa na niego funkcją: {{Code|{{sr|#p.ZamianaEncodeTekst(tekst)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)...end; </syntaxhighlight> Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst nie do końca zakodowany wydzielonego według poniższego wzoru; local tekst="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obsługa"; -- Wzór, który wydziela części do kodowania jeszcze bardziej niż były na samym początku; local wzor="[^/%?%=&:%#]+"; -- Wywołanie funkcji kodującej; local tekst2=html_modul.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor); </syntaxhighlight> Wynikiem funkcji, co kryje się pod zmienną {{Code|tekst2:}} <syntaxhighlight lang="lua"> -- Zakodowało jeszcze więcej niż na samym początku było zakodowane; local tekst2="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.StronaParametryIdentyfikacjaAdresuHtml(adres)}} == Funkcja z całkowitego adresu składający się z adresu właściwego, parametrów i nagłówka, rozdzielane jest na trzy części, z których się składa. Funkcja sprawdza, czy jakikolwiek kody {{Strong|HTML}} występują w pełnym adresie strony, jeżeli są to przedtem koduje jeszcze lepiej kody znaków {{Code|<nowiki>#</nowiki>}}, przy pomocy funkcji: {{Code|{{sr|#p.EncodeHashKoduHtmlTekstu(tekst)|p=Html}}}}, a później w kodach {{Strong|HTML}} znak {{Code|<nowiki>#</nowiki>}} jest zamieniany na kod literowy {{Strong|HTML}}, czyli: {{Code|{{Nowiki|&num;}}}}, funkcją: {{Code|{{sr|#p.EncodeTempHashKoduHtmlTekstu(tekst)|p=Html}}}} (jeżeli w adresie kody istnieją), wtedy cos powstaje w rodzaju dla kodu dziesietnego: {{Code|<nowiki>&&num;(%d+);</nowiki>}}, i szesnastkowego: {{Code|<nowiki>&&num;x(%x+);</nowiki>}} - gdzie w nich {{Code|<nowiki>#</nowiki>}} został zamieniony na {{Code|{{Nowiki|&num;}}}}, które są przedstawione według wyrażeń regularnych {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja rozdziela to na trzy części, a później odkodowuje każdą część funkcją: {{Code|{{sr|#p.DecodeTempHashKoduHtmlTekstu(tekst,...)|p=Html}}}} (jeżeli w adresie kody w ogóle istniały), i podobnie później: {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}} (jeżeli kody znaku: {{Code|<nowiki>#</nowiki>}}, były wcześniej). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.StronaParametryIdentyfikacjaAdresuHtml(adres)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - adres do potrzelenia na trzy części. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="https://pl.wikibooks.org/wiki/Strona&#32;główna&num;&#x23;&#35;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; -- Adresstrony jedynie rozkładaa się na: "strona", "parametry" i "nagłówek"; local strona,parametry,naglowek=html_modul.StronaParametryIdentyfikacjaAdresuHtml(adres); </syntaxhighlight> Otrzymane wartości tych zmiennych kryją się pod adresami: <syntaxhighlight lang="lua"> local strona,parametry,naglowek="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#35;To_nie_jest nagłówek","action=edit&section=2","Nagłówek strony",3; </syntaxhighlight> Funkcja zwraca trzy wartości, tzn. adres właściwy (bez parametrów i nagłówka), parametry (używane jako dodatek do adresów przy formułowaniu formularzy) i nagłówek (który jest adresem na stronie do odpowiedniego elementu o danym atrybucie: {{Code|id}}). == {{Code|p.TworzenieAdresuHtml(strona,...)}} == Funkcja łączy, stronę, parametry i nagłówek strony, w pełną nazwę strony (adresu), dalej jest uruchamiana funkcja ddekodująca ciagi znakowe: {{Code|{{Nowiki|&amp;&num;}}}}. Funkcja wykorzystuje do dekodowania tego {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TworzenieAdresuHtml(strona,parametry,naglowek)...end; </syntaxhighlight> Parametry funkcji: * {{Code|strona}} - nromalny adres strony, bez parametrów i nagłówka, * {{Code|parametry}} - parametry strony w formacie {{Code|nazwa{{=}}wartość}} oddzielone od siebie znakiem {{Code|<nowiki>&</nowiki>}}, * {{Code|nagłówek}} - nagłówek linkujący do {{Code|id}} jakiegos elementyna stronie, Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona,parametry,naglowek,ile="https://pl.wikibooks.org/wiki/Strona&#32;główna&num;&#35;&#x23;To_nie_jest nagłówek","action=edit&section=2","Nagłówek strony",3; local adres=html_modul.TworzenieAdresuHtml(strona,parametry,naglowek); </syntaxhighlight> Otrzymany pełny pojedynczy adres strony, z normalnym adresem strony z parametrami i nagłówkiem, jest ukryta: <syntaxhighlight lang="lua"> local adres="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#35;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; </syntaxhighlight> Funkcja zwraca całkowity adres z adresem właściwym, parametrami (po {{Code|<nowiki>?</nowiki>}}, jeżeli po nim występują wartości przyrównane nazwą zmiennych {{Strong|HTML}}) i nagłówkiem (po {{Code|<nowiki>#</nowiki>}}). == {{Code|p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)}} == Pełny adres strony, bezprotokolarny (lub protokolarny, jeżeli rozdzielimy, w pierwszej funkcji anonimowej w tej nagłówku, na protokół i adres bezprotokolarny, czyli na dwie części, zrobimy operacje, a później je złączymy w nim), linków zewnętrznych lub wewnętrznych, z adresem właściwym, parametrami i nagłówkiem strony, po podziale na je trzy części funkcją {{Code|{{sr|#p.StronaParametryIdentyfikacjaAdresuHtml(adres)|p=Html}}}}, następnie na każdą z tych elementów działamy odpowiednimi funkcjami, a potem ich wyniki łączymy w pełny adres strony funkcją {{Code|{{sr|#p.TworzenieAdresuHtml(strona,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,funkcja_strona,funkcja_parametry,funkcja_naglowek)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - pełny adres do przetworzenia, * {{Code|funkcja_strona}} - funkcja, którą działamy na właściwy adres strony, bez parametrów i nagłówka, * {{Code|funkcja_parametry}} - funkcja, którą działamy na parametry adresu strony, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek strony adresu. Przykład takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local function ParametryEncodeURL(a,b,c) return a..html_modul.ZamianaEncodeTekst(b).."="..html_modul.ZamianaEncodeTekst(c); end; local function OperacjeHtml(adres) adres=mw.ustring.gsub(adres,"^(%??)([^&=]*)=([^&]*)",ParametryEncodeURL); adres=mw.ustring.gsub(adres,"(&)([^&=]*)=([^&]*)",ParametryEncodeURL); return adres; end; return html_modul.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres, -- Funkcja: funkcja_strona; function(strona) strona=html_modul.ZamianaEncodeNaPodstawieWzoruTekstu(strona,"[^/]+"); return strona; end, -- Funkcja: funkcja_parametry; OperacjeHtml, -- Funkcja: funkcja_naglowek; function(naglowek) naglowek=html_modul.ZamianaEncodeTekst(naglowek); return naglowek; end ); </syntaxhighlight> == {{Code|p.ParametryEncodeURL(adres,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.ZamianaEncodeTekst(tekst)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.ParametryEncodeURL(adres,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="//pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obsługa"; local adres2=html_modul.ParametryEncodeURL(adres,true, function(strona) strona=html_modul.ZamianaEncodeNaPodstawieWzoruTekstu(strona,"[^/]+"); return strona; end, function(naglowek) naglowek=html_modul.ZamianaEncodeTekst(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="//pl.wikibooks.org/w/index.php?title=Szablon%3ALink_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}, ale przed nim wywoływana ajest funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a po nim {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryZaawansowanyEncodeURL(adres,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.ParametryZaawansowanyEncodeURL(adres,true, function(strona) strona=mw.uri.decode(strona); strona=html_modul.EncodeSpecjalneZnakiHtml(strona); strona=mw.uri.encode(strona); return strona; end, function(naglowek) naglowek=mw.uri.decode(naglowek); naglowek=html_modul.EncodeSpecjalneZnakiHtml(naglowek); naglowek=mw.uri.encode(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="Szablon%3ALink_wewn%C4%99trzny?action=edit#Obs%C5%82uga%26%2363%3B"; </syntaxhighlight> == {{Code|p.EncodeParametryHtml(parametr,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.EncodeHtml(...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeParametryHtml(parametr,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.EncodeParametryHtml(adres,true, function(strona) strona=html_modul.EncodeHtml(strona); return strona; end, function(naglowek) naglowek=html_modul.EncodeHtml(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="Szablon:Link_wewn%C4%99trzny?action=edit#Obs%C5%82uga%3F"; </syntaxhighlight> == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)|p=Html}}}}, a przed nim wywoływana jest {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a po nim jeżeli jest włączone kodowanie w zmiennej drugiej funkcji, wtedy {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZaawansowanyParametryHtml(adres,z_kodowaniem,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|z_kodowaniem}} - czy ostateczny nagłówek ma być zakodowany, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.EncodeZaawansowanyParametryHtml(adres,true,true, function(strona) strona=mw.uri.decode(strona); strona=html_modul.EncodePodstawoweHtmlTekstu(strona); strona=mw.uri.encode(strona); return strona; end, function(naglowek) naglowek=mw.uri.decode(naglowek); naglowek=html_modul.EncodePodstawoweHtmlTekstu(naglowek); naglowek=mw.uri.encode(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="Szablon%3ALink_wewn%C4%99trzny?action=edit#Obs%C5%82uga%26%2363%3B"; </syntaxhighlight> == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == Funkcja koduje kod {{Strong|HTML}} znaku {{Code|<nowiki>#</nowiki>}}, czyli {{Code|{{Nowiki|&num;}}}}, {{Code|{{Nowiki|&#35;}}}} i {{Code|{{Nowiki|&#x23;}}}}. Te wszystkie kody funkcja zamienia je z każdnych na kod: {{Code|{{Nowiki|&amp;num;}}}}. Funkcja zwraca przetworzony tekst, ze zmienną {{Code|ile}} mówiącej ile jest możliwych kodów na stronie, także z {{Code|ile2}} wskazującej, ile jest kodów na stronie rozwazanego znaku. Funkcja używana, gdy nie chcemy, by dodatkowe znaki {{Code|<nowiki>#</nowiki>}} przeskadzały na rozkład adresu strony na właściwy adres, parametry i nagłówek strony, co po rozkładzie wywoływana jest jego też jego funkcja odwrotna {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}}, a tak powstałe znaki {{Code|{{Nowiki|&#35;}}}} ze wszystkich tych kodów {{Code|<nowiki>#</nowiki>}} według pewnych funkcji modułu {{Code|{{ld2|Html}}}}, że one nie zostaną odkodowane, bo są one pomijane. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeHashKoduHtmlTekstu(tekst)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tekst}} - tekst do przetworzenia. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Kody do zamienienia local tekst="&num;, &#35; i &#x23;"; -- Przetwarzanie tekstu local tekst2,ile,ile2=html_modul.EncodeHashKoduHtmlTekstu(tekst); </syntaxhighlight> Wynik jest pod zmienną: <syntaxhighlight lang="lua"> -- Wszystkie możliwe warianty funkcja zamieniła na to samo, czyli na: "&amp;num;" kodu HTML "&num;" dla znaku "#"; local tekst2,ile,ile2="&amp;num;, &amp;num; i &amp;num;",3,3; </syntaxhighlight> == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == Jeżeli dokonano zamiany możliwych kodów {{Code|{{Nowiki|&num;}}}}, {{Code|{{Nowiki|&#35;}}}} i {{Code|{{Nowiki|&#x23;}}}} na {{Code|{{Nowiki|&num;num}}}}, wtedy druga zmienna jest większa od zera, wtedy możliwa jest tego zamiana na kod {{Code|{{Nowiki|&#35;}}}} kodu {{Code|{{Nowiki|&num;num}}}}, używając tej funkcji. Funkcja używana, gdy właściwy adres, parametry i nagłówek strony zostały po rozłączeniu na te części z pełnego adresu strony, wraz z innymi funkcjami odkodowującymi znaki niektóre {{Strong|HTML}}, oraz jeżeli ciało jej wersji prostej została wywołana wcześniej. Jest to odwrotność funkcji {{Code|{{sr|#p.EncodeHashKoduHtmlTekstu(tekst)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeHashKoduHtmlTekstu(tekst,ile)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tekst}} - tekst do przetworzenia, * {{Code|ile}} - {{Code|<nowiki>ile>0</nowiki>}}, jeżeli dokonano możliwych zamian kodów znaku {{Code|<nowiki>#</nowiki>}} na {{Code|{{Nowiki|&num;num}}}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Zamienione wcześniej kody: tekstu "&num;, &#35; i &#x23;", kolejno na "&amp;num;"; local tekst="&amp;num;, &amp;num; i &amp;num;"; -- Odkodowanie znaków "&amp;num;" w tekście; local tekst2=html_modul.DecodeHashKoduHtmlTekstu(tekst,3); </syntaxhighlight> Wynik jest ukryty pod zmienną: <syntaxhighlight lang="lua"> local tekst2="&#35;, &#35; i &#35;"; </syntaxhighlight> == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == Jeżeli mamy jakieś kody {{Strong|HTML}}, to aby one nie przeszkadzały w rozkładzie na właściwy adres, parametry i nagłówek strony, to te tam {{Code|<nowiki>#</nowiki>}} należy zamienić na {{Code|{{Nowiki|&num;}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeTempHashKoduHtmlTekstu(tekst)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tekst}} - tekst do przetworzenia. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Mamy tutaj kody HTML znaku: "#", czyli: "&#35;" i "&#x23;" oraz jeden od spacji: "&#32;";, a tam "#"zamieniamy na "&num;"; local tekst="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; -- Otrzymamy przetworzony tekst oraz ile uzyskamy znaków z kodem HTML dziesiętnym "ile1" i szesnastkowym "ile2"; local tekst2,ile1,ile2=html_modul.EncodeTempHashKoduHtmlTekstu(tekst); </syntaxhighlight> Wynik tego jest pod zmienną: <syntaxhighlight lang="lua"> local tekst2,ile1,ile2="https://pl.wikibooks.org/wiki/Strona&&num;32;główna&&num;35;&&num;35;&&num;x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony",3,1; </syntaxhighlight> == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == Jeżeli mamy jakieś kody {{Strong|HTML}}, to aby one nie przeszkadzały w rozkładzie na właściwy adres, parametry i nagłówek strony, to te tam {{Code|<nowiki>#</nowiki>}} należy zamienić na {{Code|{{Nowiki|&num;}}}}. One tak zostały zamienione funkcją {{Code|{{sr|#p.EncodeTempHashKoduHtmlTekstu(tekst)|p=Html}}}}. Po rozłożeniu na trzy części pełnego adresu strony, tzn. na właściwy adres, parametry i nagłówek strony, możemy wywołać dla każdej z nich tę funkcję, wykonując operację odwrotną. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeTempHashKoduHtmlTekstu(tekst,ile1,ile2)...end; </syntaxhighlight> Parametry zwykłe funkcji: * {{Code|tekst}} - tekst do przetworzenia i po rozdzieleniu na trzy części, * {{Code|ile1}} - ile jest przetworzonych kodów dziesietnych prez funkcje do rozważanej prostej, * {{Code|ile2}} - ile jest przetworzonych kodów szesnastkowych przez funkcją do rozważanej prostej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Mamy tutaj kody HTML znaku: "#", czyli: "&&num;35;" i "&&num;x23;" oraz jeden od spacji: "&&num;32;";, a tam "#"zamieniamy na "&num;"; local tekst="https://pl.wikibooks.org/wiki/Strona&&num;32;główna&&num;35;&&num;35;&&num;x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; -- Otrzymamy przetworzony tekst, do którego wsadzamy ile uzyskamy znaków z kodem HTML dziesiętnym "ile1" i szesnastkowym "ile2" w wywołaniu local tekst,ile1,ile2=p.EncodeTempHashKoduHtmlTekstu(tekst); local tekst2=html_modul.EncodeTempHashKoduHtmlTekstu(tekst,3,1); </syntaxhighlight> Wynik tego jest pod zmienną: <syntaxhighlight lang="lua"> local tekst2="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; </syntaxhighlight> == {{Code|p.AdresDomniemanieBezProtokolarnyEncodeURL(adres,...)}} == Funkcja domyślnie koduje adres bezprotokolarny, a z podaniem drugiej wartości {{Code|true}} protokolarny. Funkcja wykorzystuje funkcję {{Code|{{sr|#p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)|p=Html}}}}. A jeżeli druga wartość odpowiada prawdziwości, to korzystamy z {{Code|{{sr|#p["UrlBezProtokołu"](frame)|p=Html}}}} na rozkład na adres bezprotokolarny i protokół. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.AdresDomniemanieBezProtokolarnyEncodeURL(adres,protokolarny)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - adres do zakodowania, * {{Code|protokolarny}} - czy ma rozkładać adres na nazwę strony i protokół. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Adres protokonalny; local adres11="https://pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; local adres12=html_modul.AdresDomniemanieBezProtokolarnyEncodeURL(adres11,true); -- Adres bezprotokonalny; local adres21="//pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; local adres22=html_modul.AdresDomniemanieBezProtokolarnyEncodeURL(adres21,false); </syntaxhighlight> Wynik wartości {{Code|adres12}} i {{Code|adres12}} jest: <syntaxhighlight lang="lua"> -- Zakodowany adres z protokołem local adres12="https://pl.wikibooks.org/wiki/Strona_g%C5%82%C3%B3wna?action=edit&section=2#Nag%C5%82%C3%B3wek%20strony"; -- Zakodowany adres bez protokołu local adres22="//pl.wikibooks.org/wiki/Strona_g%C5%82%C3%B3wna?action=edit&section=2#Nag%C5%82%C3%B3wek%20strony"; </syntaxhighlight> == {{Code|p.UriEncode(frame)}} == Funkcja do kodowania adresów tylko z protokołem, wartości bez protokołu nie obsługuje. Wykorzystuje {{Code|{{sr|#p.AdresDomniemanieBezProtokolarnyEncodeURL(adres,...)|p=Html}}}}. Do wyszukiwania adresów jest brana funkcja {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.UriEncode(frame)...end; </syntaxhighlight> Parametry tablicy ramki tablicy transportu: * {{Code|html}} - adres z protokołem strony. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|html}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Adres protokonalny; local adres="https://pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; -- Równoważnie: local adres2=html_modul.UriEncode{html=adres,}; local adres2=html_modul.UriEncode(adres); </syntaxhighlight> Wynik jest w zmiennej: <syntaxhighlight lang="lua"> local adres2="https://pl.wikibooks.org/wiki/Strona_g%C5%82%C3%B3wna?action=edit&section=2#Nag%C5%82%C3%B3wek%20strony"; </syntaxhighlight> == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == Funkcja blokuje odkodowywanie możliwych kodów {{Strong|HTML}} znaku {{Code|<nowiki>#</nowiki>}}, w tym celu wywoływana jest funkcja: {{Code|{{sr|#p.KodowanieOmijanieFunkcyjne(html,...)|p=Html}}}}, do omijania tego znaku, funkcja omija tylko znaki zapisane w kodach {{Strong|HTML}}, tzn. {{Code|{{Nowiki|&#35}}}}, w tym celu wszystkie kody tego znaku zamieniamy na jeden, przed wywołaniem tej funkcji, funkcjami: {{Code|{{sr|#p.EncodeHashKoduHtmlTekstu(tekst)|p=Html}}}} i {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}}. Ta funkcja w pierwszym kroku, w nim we wspomnianej funkcji wywołanej w funkcji anonimowej, wywołuje funkcję dekodujące znaki, czyli: {{Code|{{sr|#p.DecodeKoduHTMLZnaku(tekst)|p=Html}}}}, do odkodowania kodów, {{Strong|HTML}}, dziesiętnych, szesnastkowych i literowych. Na samym końcu kodowane są specjalne znaki na podstawie: {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}, na kody {{Strong|HTML}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)...end; </syntaxhighlight> Parametry funkcji: * {{Code|elementy_adresu_strony}} - funkcja do podstawowego kodowania adresu. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.EncodePodstawoweHtmlTekstu(adres); </syntaxhighlight> Wartość zmiennej jest ukryta pod: <syntaxhighlight lang="lua"> local adres2="Szablon:Link_wewnętrzny&#63;action&#61;edit&#35;Obsługa&#63;"; </syntaxhighlight> == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == Gdy mamy problem (przypadek) z parametrami adresu strony,wtedy do kodowania wywoływana jest funkcja {{Code|{{sr|#p.EncodeZaawansowanyParametryHtml(adres,...)|p=Html}}}}, a gdy posługujemy się właściwym adresem strony lub nagłówkiem, wtedy dekodujemy '''URL''' funkcją {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, następnie {{Code|{{sr|#p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)|p=Html}}}}, i jeżeli mały włączone kodowanie, następnie {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeElementyAdresuStrony(elementy_adresu_strony,czy_parametry_strony,z_kodowaniem)...end; </syntaxhighlight> Parametry funkcji: * {{Code|elementy_adresu_strony}} - element adresu strony, * {{Code|czy_parametry_strony}} - czy parametry strony rozważać, jako że wtedy jest taki adres jako parametry, * {{Code|z_kodowaniem}} - czy jest włączone kodowanie funkcji po odkodowaniu i pewnych operacjach w tej funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local elementy_adresu_strony="Obsługa?"; local elementy_adresu_strony2=html_modul.EncodeElementyAdresuStrony(elementy_adresu_strony,false,true); </syntaxhighlight> Wartość zmiennej jest ukryta pod: <syntaxhighlight lang="lua"> local elementy_adresu_strony2="Obs%C5%82uga%26%2363%3B"; </syntaxhighlight> == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == Funkcja korzysta do dekodowania na samym początku '''URL''' {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a na końcu {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}, jeżeli jest włączone kodowanie, między czasie korzysta z {{Code|{{sr|#p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)|p=Html}}}}. Główny elementem funkcyjnym jest {{Code|{{sr|#p.EncodeZaawansowanyParametryHtml(adres,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.AdresProjektuEncodeHtml(frame,z_kodowaniem,protokolarny)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|z_kodowaniem}} - czy końcowo kodować, * {{Code|protokolarny}} - czy uważać przy kodowaniu na protokoły pełnych adresów stron. Parametry tablicy ramki tabeli transportu: * {{Code|html}} - adres do kodowania, * {{Code|encode}} - czy kodować. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|html}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="https://pl.wikibooks.org/wiki/Strona_&główna?&?action=edit&section=2&title=Nazwa strony szablonu: {{!}}#Nagłówek strony"; local adres2=html_modul.AdresProjektuEncodeHtml(adres,false,true); local adres3=html_modul.AdresProjektuEncodeHtml(adres,true,true); </syntaxhighlight> Wartość zmiennej jest ukryta pod: <syntaxhighlight lang="lua"> local adres2="https://pl.wikibooks.org/wiki/Strona_&#38;główna&#63;&#38;?action=edit&section=2&title=Nazwa strony szablonu: &#123;&#123;!&#125;&#125;#Nagłówek strony"; local adres3="https://pl.wikibooks.org/wiki/Strona_%26%2338%3Bg%C5%82%C3%B3wna%26%2363%3B%26%2338%3B?action=edit&section=2&title=Nazwa%20strony%20szablonu%3A%20%26%23123%3B%26%23123%3B%21%26%23125%3B%26%23125%3B#Nag%C5%82%C3%B3wek%20strony"; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> je88t3lszhguyhjhw0778m8oglp0670 541355 541353 2026-04-30T08:17:57Z Persino 2851 541355 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ę dziesiętnymi, szesnastkowymi i literowymi kodami {{Strong|HTML}} i zamieniania ich na odpowiednie znaki, zamieniania znaków na ich kody dziesiętne, 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 łączenie z powrotem do innej wartości zwykle niż wcześniej tego samego ciągu. == {{Code|p.KodowanieOmijanieFunkcyjne(html,...)}} == Funkcja wywołuje funkcję modułu {{Code|{{ld2|Szeregi}}}} zwaną {{Code|{{sr|#p.SzeregiOmijanieFunkcyjne(tekst,...)|p=Szeregi}}}}. Domyślnym wzorem jest {{Code|<nowiki>&([^&;%s]+);</nowiki>}}, ale można go zmienić na inny. Drugą funkcją podawaną do tej funkcji jest domyślnym obiektem funkcyjnym anonimowym, który nie podaje się do funkcji w nagłówku: <syntaxhighlight lang="lua"> function(kod) return "&"..kod..";"; end </syntaxhighlight> Gdzie {{Code|kod}} jest elementem przechwytywanym kodu {{Strong|HTML}}, który jest określony poprzez nawiasy okrągłe we wzorze podawanym jako argument lub, jeśli jest on równy {{Code|nil}}, wtedy we wzorze domyślnym, który w takim razie jest rozpatrywany. Funkcja służy do omijania wszystkich kodów {{Strong|HTML}} lub tylko niektórych i robienia na nich operacji za pomocą funkcji podawanej jako ostatni parametr. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.KodowanieOmijanieFunkcyjne(html,normalnie,wzor,funkcja)...end; </syntaxhighlight> Parametry funkcji: * {{Code|html}} - ciąg do przetworzenia, w częściach bez parametrów omijanych, * {{Code|normalnie}} - czy ma przetwarzać tekst pomijając, w przeciwnym wypadku tak nie robi, * {{Code|wzor}} - wzór do elementów pomijanych, wzór może mieć tylko jeden element przechwytywany, * {{Code|funkcja}} - funkcja robiąca operacje na przetworzonych subciągach bez elementów pomijanych. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="Oto jest tekst wywołania: \"&#35;\""; local tekst2=html_modul.KodowanieOmijanieFunkcyjne(tekst,true,"&(#35);",function(tekst) return mw.uri.encode(tekst); end); </syntaxhighlight> Wyniki działania: <syntaxhighlight lang="lua"> local tekst2="Oto+jest+tekst+wywo%C5%82ania%3A+%22&#35;%22"; </syntaxhighlight> == {{Code|p["TransformacjaKlasyZnakowejDoKoduHtmlCiągu"](frame)}} == Funkcja zamienia znaki specjalne wikikodu i wyrażeń regularnych na kody dziesiętne {{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 się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <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 się tekst do zamiany kodów {{Strong|HTML}}, dziesiętnych i szesnastkowych, na znaki. 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <syntaxhighlight lang="lua"> local tekst2="Oto jest link: [[user:użytkownik|(Użytkownik)]]."; </syntaxhighlight> == {{Code|p.ZnakiSpecjalneTaguNowiki(frame)}} == Funkcja zamienia znaki specjalne, w tekście (w zawartości pomiędzy tagami tagu {{Tag|nowiki}}, by potem je tam umieścić, by pierwotna zawartość równała się tekstowi wyświetlanemu (aby on zamieniał się na tylko zwykły tekst, by nie był dalej rozwijalny względem funkcji: {{Code|frame:preproces}})), wikikodu na kody dziesiętne {{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 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 się tekst do zamiany znaków, z zestawu znaków specjalnych wskazanych w funkcji, występujących w tagach języka '''HTML''' do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <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 się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <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,normalnie)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}. Parametry ramki funkcji tablicy transportu: * {{Code|html}} - zmienna, pod którym wyszukuje się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego kodu {{Strong|HTML}}, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}, jeżeli jej wartość odpowiada wartości logicznej {{Code|false}}, wtedy liczy się jej wersja parametrowa funkcji. 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|html}}. 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> Wyniki działania: <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 samym początku, to jest określane 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 się tekst do zamiany z podanego zestawu znaków pierwszych znaków listy, mechanizmu {{Strong|MediaWiki}}, do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <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 zamienia znaki {{Code|<nowiki>=%?&</nowiki>}} na kody dziesiętne {{Strong|HTML}}. Funkcja potrzebuje do wyszukiwania parametrów do działania, funkcji: {{Code|{{sr|#p.PobierzParametryRamki(frame)|p=Parametry}}}}. Funkcja potrafi opcjonalnie omijać kody {{Strong|HTML}}, w zależności od podanego drugiego parametru. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryPrzypisaniaZnakowegoEncodeHtml(frame,normalnie)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}. Parametry ramki funkcji tablicy transportu: * {{Code|tekst}} - zmienna, pod którym wyszukuje się tekst do zamiany z zestawu znaków specjalnych, wskazanych w funkcji, do dziesiętnego kodu {{Strong|HTML}}, * {{Code|normalnie}} - czy ma omijać kody {{Strong|HTML}}, jeżeli jej wartość odpowiada wartości logicznej {{Code|false}}, wtedy liczy się jej wersja parametrowa funkcji. 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <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 się tekst do zamiany znaków przypisania {{Code|{{=}}}} do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <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 dziesiętne {{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 się tekst do zamiany ze znaku dwukropka do dziesiętnego 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. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|tekst}}. 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> Wyniki działania: <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 dziesiętny {{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 dziesiętny {{Strong|HTML}}, * {{Code|2}} - czy znak {{Code|{{Nowiki|&}}}} ma być zamieniany na {{Code|{{Nowiki|&amp;}}}}, a znak {{Code|<nowiki>#</nowiki>}} na {{Code|{{Nowiki|&num;}}}}. 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}}. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}. 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> Wyniki działania: <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 === Zamienia ściśle określone znaki (zestaw kodów znajduje się na stronie: {{Code|{{ls2|KodyHTMLZnakówWikiCiągu/opis}}}}) na kody dziesiętne {{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["KodyHTMLZnakówWikiCiągu"](frame)...end; </syntaxhighlight> Parametry ramki funkcji tablicy transportu: * {{Code|1}} - ciąg, pod którym są możliwe ściśle określone znaki są zamieniane na kod {{Strong|HTML}}, ciąg ten jest ze znakami wiki w UTF8, * {{Code|2}} - czy znak {{Code|{{Nowiki|&}}}} ma być zamieniany na {{Code|{{Nowiki|&amp;}}}} i {{Code|<nowiki>#</nowiki>}} na {{Code|{{Nowiki|&num;}}}}. 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}}. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="k{{s"; -- Równoważne: local tekst2=html_modul["KodyHTMLZnakówWikiCiągu"]{[1]=tekst,}; -- Równoważne: local tekst2=html_modul["KodyHTMLZnakówWikiCiągu"]{args={[1]=tekst,},}; local tekst2=html_modul["KodyHTMLZnakówWikiCiągu"](znak); -- Równoważne: local tekst3=html_modul["KodyHTMLZnakówWikiCiągu"]{[1]=tekst,[1]="tak",}; local tekst3=html_modul["KodyHTMLZnakówWikiCiągu"]{args={[1]=tekst,[2]="tak",},}; </syntaxhighlight> Wyniki działania: <syntaxhighlight lang="lua"> local tekst2="k&#123;&#123;s"; local tekst3="k&amp;&num;123;&amp;&num;123;s"; </syntaxhighlight> Szablonowo taką zamianę możemy napisać: * {{Code|{{s|KodyHTMLZnakówWikiCiągu|k{{s|((}}s}}}} → {{Tt|{{KodyHTMLZnakówWikiCiągu|k{{((}}s}}}} * {{Code|{{s|Nowiki|{{s|KodyHTMLZnakówWikiCiągu|k{{s|((}}s}}}}}} → {{Tt|{{Nowiki|{{KodyHTMLZnakówWikiCiągu|k{{((}}s}}}}}} * {{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}}}}}} Równie dobrze możemy napisać takie wywołania w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}}: <syntaxhighlight lang="mediawiki"> <!-- Wyświetla wynik: "k&#123;&#123;s"; --> {{#invoke:Html|KodyHTMLZnakówWikiCiągu|k{{((}}s|wyspecjalizowana=tak}} <!-- Wyświetla wynik: "k&amp;&num;123;&amp;&num;123;s"; --> {{#invoke:Html|KodyHTMLZnakówWikiCiągu|k{{((}}s|tak|wyspecjalizowana=tak}} </syntaxhighlight> == {{Code|p.EncodeId(...)}} == Funkcja służy do opcjonalnego dekodowania ciągów znakowych według {{Code|{{sr|#p.DecodeHtml(...)|p=Html}}}}, i cały ciąg od specjalnych znaków jest transformowany przez funkcję {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeId(id,bez_transformacji)...end; </syntaxhighlight> Parametry nieramkowe normalne funkcji: * {{Code|id}} - ciąg do przeinaczenia, * {{Code|bez_transformacji}} - gdy nie {{Code|false}} lub {{Code|nil}}, funkcja nie transformuje na podstawie: {{Code|{{sr|#p.DecodeHtml(...)|p=Html}}}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local id="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; local id2=html_modul.EncodeId(id,false); </syntaxhighlight> Wynikiem tego: <syntaxhighlight lang="lua"> local id2="https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link wewnętrzny&#38;action&#61;edit&#35;Obsługa"; </syntaxhighlight> Gdy: {{Code|bez_transformacji{{=}}true}}, funkcja działa jak: {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}, ale wtedy {{Code|frame{{=}}id}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local id="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; local id2=html_modul.EncodeId(id,true); </syntaxhighlight> Wynikiem działania jest wartość ostatniej zmiennej: <syntaxhighlight lang="lua"> local id2="https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link_wewn%C4%99trzny&#38;action&#61;edit&#35;Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)}} == Usuwa z tekstu znak numer {{Code|8206}} zestawu {{lpg|Unicode}}, który można napisać, jeśli jest widoczny na ekranie komputera {{Code|&#8206;}} (znak {{Code|{{Nowiki|&#8206;}}}}). Ten znak oczywiście Unicode jest w grupie zwanej invisible Unicode characters i służy do ustawiania kierunku tekstu lewo do prawo. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)...end; </syntaxhighlight> Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tutaj jest zakodowany znak HTML, o kodzie dziesiętnym "&#8206;", składający się z trzech bajtów: "&#226;", "&#128;" i "&#142;"; local tekst="Oto jest znak: &#8206;."; -- Zamiana tego kodu na znak; tekst=html_modul["TransformacjaKoduHtmlDoZnakuCiągu"](tekst); -- Tekst bez tego znaku, bo on został w tym wywołaniu całkowicie usunięty; tekst=html_modul.UsuwanieSpecjalnychNieschematycznychSymboli(tekst); </syntaxhighlight> Wynikiem tego kodu jest wartość ukryta pod zmienną: <syntaxhighlight lang="lua"> local tekst="Oto jest znak: ."; </syntaxhighlight> == {{Code|p.EncodeWiki(...)}} == Funkcja transformuje kody {{Strong|HTML}} do znaku przy pomocy funkcji {{Code|{{sr|#p["TransformacjaKoduHtmlDoZnakuCiągu"](frame)|p=Html}}}}, usuwa nieschematyczne znaki o kodzie {{Code|{{Nowiki|&#8206;}}}} dzięki funkcji: {{Code|{{sr|#p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)|p=Html}}}}, następnie opcjonalnie usuwa znaki będące odstępami lub dolnymi myślnikami z początku i końca tekstu, i zamienia wewnątrz znaki kolejne odstępów lub dolnych myślników na jeden dolny myślnik na podstawie {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}, dalej zaraz funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.text.encode|n=mw.text.encode}}}} koduje tekst, tą funkcją {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeWiki(parametr,czy_nie_odstepy)...end; </syntaxhighlight> Parametry funkcji: * {{Code|parametr}} - tekst, który chcemy zakodować, * {{Code|czy_nie_odstepy}} - czy nie ma na tekst podziałać funkcją {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local parametr="__Oto jest znak: \"&#8206;\" i inne_znaki_w_URL: \"https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link wewnętrzny&#38;action&#61;edit&#35;Obsługa;\"__"; local parametr2=html_modul.EncodeWiki(parametr,false); local parametr3=html_modul.EncodeWiki(parametr,true); </syntaxhighlight> Wynikiem działania tej funkcji jest parametr {{Code|parametr2}} i {{Code|parametr3}}, którego wartości: <syntaxhighlight lang="lua"> local parametr2="Oto_jest_znak:_&quot;&quot;_i_inne_znaki_w_URL:_&quot;https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewnętrzny&amp;action=edit#Obsługa;&quot;"; local parametr3="__Oto jest znak: &quot;&quot; i inne_znaki_w_URL: &quot;https://pl.wikibooks.org/w/index.php?title=Szablon:Link wewnętrzny&amp;action=edit#Obsługa;&quot;__"; </syntaxhighlight> == {{Code|p.DecodeWiki(...)}} == Funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.text.decode|n=mw.text.decode}}}} dekoduje tekst, tą funkcją {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Następnie usuwa nieschematyczne symbole: {{Code|{{Nowiki|&#8206;}}}}, dzięki funkcji: {{Code|{{sr|#p.UsuwanieSpecjalnychNieschematycznychSymboli(parametr)|p=Html}}}}, następnie działa opcjonalnie funkcją, która usuwa znaki będące odstępami lub dolnymi myślnikami z początku i końca tekstu oraz zamieniając wewnątrz znaki kolejne odstępów lub dolnych myślników na jedną dolną spacją na podstawie {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeWiki(parametr,czy_nie_odstepy)...end; </syntaxhighlight> Parametry funkcji: * {{Code|parametr}} - tekst, który chcemy odkodować, * {{Code|czy_nie_odstepy}} - czy nie ma na tekst podziałać funkcją {{Code|{{sr|#p["Odstępy"](frame)|p=Parametry}}}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local parametr="__Oto jest znak: &quot;&#8206;&quot; i inne_znaki_w_URL: &quot;https://pl.wikibooks.org/w/index.php&#63;title&#61;Szablon:Link wewnętrzny&#38;action&#61;edit&#35;Obsługa;&quot;__"; local parametr2=html_modul.DecodeWiki(parametr,false); local parametr3=html_modul.DecodeWiki(parametr,true); </syntaxhighlight> Wynikiem działania tej funkcji jest parametr {{Code|parametr2}} i {{Code|parametr3}}, którego wartość: <syntaxhighlight lang="lua"> local parametr2="Oto jest znak: \"\" i inne znaki w URL: \"https://pl.wikibooks.org/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa;\""; local parametr3="__Oto jest znak: \"\" i inne_znaki_w_URL: \"https://pl.wikibooks.org/w/index.php?title=Szablon:Link wewnętrzny&action=edit#Obsługa;\"__"; </syntaxhighlight> == {{Code|p.IsEncodedHtml(...)}} == Funkcja sprawdza, czy można uznać, że funkcja jest zakodowana, tzn. dalej nie warto jej kodować przy pomocy funkcji: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}, czy dekodować, bo już można uznać ją za odkodowaną, czyli nie trzeba stosować funkcji: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}. Funkcja zwraca wartość {{Code|true}}, jak można uznać tekst za zakodowany i {{Code|false}}, gdy jest niezakodowana. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.IsEncodedHtml(parametr,encode,encode_real)..end; </syntaxhighlight> Parametry funkcji: * {{Code|parametr}} - parametr do sprawdzenia - wymagany, * {{Code|encode}} - gdy jest sprawdzana tylko obecność znaku {{Code|%}}, * {{Code|encode_real}} - gdy jest sprawdzana, nie tylko obecność znaku {{Code|%}}, też czy {{Code|parametr}} jest ciągiem podporządkowanym wyrażeniu regularnemu {{Code|<nowiki>^[%w%p%s]*$</nowiki>}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Pierwszy przykład: local parametr1="abc?edit=action"; -- Wartość zmiennej obliczona jest: czy_tak1=true, czyli parametr1 można uznać za zakodowany; local czy_tak1=html_modul.IsEncodedHtml(parametr1,true,false); -- Drugi przykład: local parametr2="a%YTbc?edit=action;"; -- Wartość zmiennej obliczona jest: czy_tak2=false; czyli parametr2można uznać, że nie jest zakodowany; local czy_tak2=html_modul.IsEncodedHtml(parametr2,true,false); </syntaxhighlight> == {{Code|p.EncodeHtml(...)}} == Funkcja sprawdza, czy podany parametr do transformacji uznać za zakodowany, jeżeli za taki zostanie uznany, wtedy zostanie, to on zostanie potraktowany funkcją {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}, a jeżeli nie to zostanie wywołana funkcja: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}} (z parametrem "WIKI"). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeHtml(parametr,encode,encode_real,czy_nie_odstepy)...end; </syntaxhighlight> Parametry funkcji: * {{Code|parametr}} - parametr do transformacji kodowania, * {{Code|encode}} i {{Code|encode_real}} - te parametry to samo oznaczają, co w funkcji: {{Code|{{sr|#p.IsEncodedHtml(...)|p=Html}}}}, * {{Code|czy_nie_odstepy}} - to samo oznacza, co w funkcji {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}. {{Hr}} Przykłady pierwszy - podany tekst już zakodowany: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst do zakodowania; local parametr="abc___&#63;action&#61;edit&#38;section&#61;21&#35;nagłówek"; -- Tekst zostanie uznany za zakodowany, sprawdzane, czy on ma znaki "%", czyli on tego nie posiada; local parametr2=html_modul.EncodeHtml(parametr,true,false,false); </syntaxhighlight> Wynik zmiennej {{Code|parametr2}} jest ukryty pod jego wartością: <syntaxhighlight lang="lua"> -- Widzimy, że podwojone myślniki dolne zostały zamienione na pojedyncze, kody HTML zostały zamienione na znaki, a znak "&#38;", czyli "&" został zamieniony na "&amp;"; local parametr2="abc_?action=edit&amp;section=21#nagłówek"; </syntaxhighlight> {{Hr}} Przykłady drugi - podany tekst jeszcze nie zakodowany: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst do zakodowania; local parametr="a%YTbc___?action=edit;"; -- Tekst zostanie uznany za niezakodowany, czy on ma znaki "%", czyli on to posiada; local parametr2=html_modul.EncodeHtml(parametr,true,false,false); </syntaxhighlight> Wynik zmiennej {{Code|parametr2}} jest ukryty pod jego wartością: <syntaxhighlight lang="lua"> -- Widzimy, że znak "%" został zakodowany funkcją mw.uri.encode, podobnie tą funkcją zostały zakodowane: "?" i "="; local parametr2="a%25YTbc___%3Faction%3Dedit;"; </syntaxhighlight> == {{Code|p.DecodeHtml(...)}} == Funkcja sprawdza, czy {{Code|parametr}}, czy można uznać za zakodowany, a jeżeli można, to on zostanie w zależnosci od parametru {{Code|spacje}}, to odpowiednio zostanie wywołana {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a następnie w zależności od parametru (opis w parametrach) zostanie wywołana odpowiednia funkcja odkoduwująca lub kodująca {{Code|wiki}}. Jeżeli ciąg rzeczywiście jest uznany za niezakodowany jest podobnie odpowiednio z tylko z wywołaniami funkcji {{Code|wiki}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeHtml(parametr,spacje,encode,encode_real,czy_nie_odstepy)...end; </syntaxhighlight> Parametry funkcji: * {{Code|parametr}} - parametr do odkodowania, * {{Code|spacje}} - gdy parametr odpowiada {{Code|true}} używa funkcji {{Code|{{sr|#p.DecodeWiki(...)|p=Html}}}}, w przeciwnym wypadku: {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}, ale wpierw musi zostać wywołana funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}} w przypadku, gdy ciąg zostanie uznany za zakodowany, jak to robi funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}, * {{Code|encode}} i {{Code|encode_real}} - te parametry są używane przez funkcje {{Code|{{sr|#p.IsEncodedHtml(...)|p=Html}}}}, * {{Code|czy_nie_odstepy}} - gdy ciąg został uznany za niezakodowany, wtedy to jest drugi parametr funkcji: {{Code|{{sr|#p.DecodeWiki(...)|p=Html}}}} lub {{Code|{{sr|#p.EncodeWiki(...)|p=Html}}}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Parametr zawiera znaki zakodowane funkcją mw.uri.encode i kody HTML znaków; local parametr="a%25YTbc___%3Faction%3Dedit&#38;section&#61;23;"; local parametr2=html_modul.DecodeHtml(parametr,true); </syntaxhighlight> Wynik funkcji jest ukryty pod adresem: <syntaxhighlight lang="lua"> -- Funkcja została uznana za zakodowaną i odkodowano ją funkcją mw.uri.decode, dalej dwa dolne myślniki zostały zamienione na jedną spację, a kody HTML zostały zamienione na odpowiednie znaki; local parametr2="a%YTbc ?action=edit&section=23;"; </syntaxhighlight> == {{Code|p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)}} == Szuka atrybutów w cudzysłowach i w nich elementy {{Code|<nowiki><>&</nowiki>}} zamienia na kody dziesiętne {{Strong|HTML}}, a także znaki lewego ukośnika {{Code|<nowiki>\</nowiki>}} też na to. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(znacznik)...end; </syntaxhighlight> Parametry funkcji: * {{Code|znacznik}} - atrybut do przetwarzania, aby w nim zamienić niektóre znaki, które przeszkadzają w analizie na kody, o odpowiednim formacie, {{Strong|HTML}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="<span id=\"Znaki<>\\\"\">To jest zawartość</span>"; local tekst2=html_modul.TekstoweZnakiTypowoTagoweParametroweZamienianiaNaKodHtml(tekst); </syntaxhighlight> Wartość tej zmiennej jest ukryta pod {{Code|tekst2}}: <syntaxhighlight lang="lua"> -- Widzimy, że został sam jeden atrybut ze znakami HTML wewnątrz; local tekst2="<span id=\"Znaki&lt;&gt;&#92;&#34;\">To jest zawartość</span>"; </syntaxhighlight> == {{Code|p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)}} == Zamienia kody {{Strong|HTML}}, tzn.: {{Code|{{Nowiki|&lt;}}}}, {{Code|{{Nowiki|&gt;}}}} i {{Code|{{Nowiki|&amp;}}}}, na odpowiednio znaki, a także elementy {{Code|{{Nowiki|&#92;&#34;}}}} na {{Code|<nowiki>\"</nowiki>}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(value)...end; </syntaxhighlight> Parametry funkcji: * {{Code|value}} - parametr do transformacji niektórych kodów {{Strong|HTML}} na znaki. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="&lt;a href=\"/wiki/Strona?tytan1=1&amp;tytan2=2\" id=\"Strona:&#92;&#34;nazwa&#92;&#34;\"&gt;Zawartość znacznika&lt;/a&gt;"; local tekst2=html_modul.TekstoweKodyHtmlZnacznikoweTypowoTagoweParametroweZamienianiaNaZnak(tekst); </syntaxhighlight> Otrzymana zawartość jest pod {{Code|tekst2}}: <syntaxhighlight lang="lua"> -- Widzimy, że kody odpowiednie HTML, tzn.: "&lt;", "&gt;" i "&amp;" zostały zamienione na odpowwiednie znaki; local tekst2="<a href=\"/wiki/Strona?tytan1=1&tytan2=2\" id=\"Strona:\\\"nazwa\\\"\">Zawartość znacznika</a>"; </syntaxhighlight> == {{Code|p["NagłówekStronyAdresu"](frame,...)}} == Funkcja wydziela nagłówek z adresu strony, funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NagłówekStronyAdresu"]=function(frame,czy_nie_dolne_myslniki,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_nie_dolne_myslniki}} - gdy {{Code|true}}, jeśli w nagłówku nie ma prawa być dolnych myślników, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Funkcja usuwa zbędne odstępy i dolne myślniki na końcach nagłówka, i powtarzające się znaki będące odstępami lub dolnymi myślnikami są zastępowane przez jedną spację, gdy {{Code|czy_nie_dolne_myslniki}} równa jest wartości odpowiadającej {{Code|true}}, w przeciwnym wypadku zamieniana jest ona na jeden dolny myślnik. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_nie_dolne_myslniki}} (parametr funkcji), {{Code|2}} lub {{Code|z nie dolnymi z myślnikami}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local naglowek=html_modul["NagłówekStronyAdresu"](strona,true,tabela_nazw_adresu); local naglowek=html_modul["NagłówekStronyAdresu"]({strona=strona,["z nie dolnymi z myślnikami"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony, nagłówek usuwając z niego myślniki dolne i trimując zawartość; local naglowek="Nagłówek strony"; </syntaxhighlight> == {{Code|p["ParametryStronyAdresu"](frame,...)}} == Funkcja wydziela parametry z adresu strony, funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["ParametryStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma suwać zbędne odstępy i dolne myślniki z parametrów adresu, wydzieloną z pełnego adresu strony, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local parametry=html_modul["ParametryStronyAdresu"](strona,true,tabela_nazw_adresu); local parametry=html_modul["ParametryStronyAdresu"]({strona=strona,["czy naprawiać"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony parametry, usuwając z niego zbędne odstępy i myślniki dolne; local parametry="action=edit&section=2"; </syntaxhighlight> == {{Code|p["NazwaStronyAdresu"](frame,...)}} == Funkcja wydziela nazwę strony z adresu strony, funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["NazwaStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma suwać zbędne odstępy i dolne myślniki z adresu strony, bez parametrów i nagłówka, wydzieloną z pełnego adresu strony, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local parametry=html_modul["NazwaStronyAdresu"](strona,true,tabela_nazw_adresu); local nazwa_strony=html_modul["NazwaStronyAdresu"]({strona=strona,["czy naprawiać"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony nazwę strony adresu, usuwając z niego zbędne odstępy i myślniki dolne; local nazwa_strony="https://pl.wikibooks.org/wiki/Strona_główna"; </syntaxhighlight> == {{Code|p["NazwaStronyZParametrówStronyAdresu"](frame,...)}} == Funkcja wydziela nazwę strony z parametrów adresu strony. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. <syntaxhighlight lang="lua"> p["NazwaStronyZParametrówStronyAdresu"]=function(frame,czy_naprawiaj)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma suwać zbędne odstępy i dolne myślniki z parametrów strony adresu, i czy zamieniać je na pojedyncze spacje wewnątrz nazwy artykułu wydzieloną z parametrów strony. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}} lub {{Code|parametry}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}} lub {{Code|parametry}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="title=Strona ___ główna & action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; -- Równoważne: local parametry=html_modul["NazwaStronyZParametrówStronyAdresu"](strona,true); local nazwa_strony=html_modul["NazwaStronyZParametrówStronyAdresu"]({parametry=strona,["czy naprawiać"]=true,},nil); </syntaxhighlight> Wartość nagłówka jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z adresu strony nazwę artykułu, usuwając z niego zbędne odstępy i myślniki dolne; local nazwa_strony="Strona główna"; </syntaxhighlight> == {{Code|p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](frame,...)}} == Funkcja poprawia pełny adres strony, rozdzielając ją na części, a później łącząc. Funkcja ma własną tabelę buforową nazw. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["PoprawAdresNagłówkaOrazParametrówStronyAdresu"]=function(frame,czy_naprawiaj,tabela_nazw_adresu)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki funkcji tablicy transportu, * {{Code|czy_naprawiaj}} - parametr przedstawiający, czy ma naprawiać pełny adres strony, działając w sposób specyficzny w zależności od funkcji, która operuje na jej częściach, wykorzystując funkcje, które są napisane w linii zaraz poniżej, * {{Code|tabela_nazw_adresu}} - tabela nazw zespołu funkcji, która obejmuje funkcje {{Code|{{sr|#p["NagłówekStronyAdresu"](frame,...)|p=Html}}}}, {{Code|{{sr|#p["ParametryStronyAdresu"](frame,...)|p=Html}}}} i {{Code|{{sr|#p["NazwaStronyAdresu"](frame,...)|p=Html}}}}. Parametry funkcji ramki parametry {{Code|frame}}: * {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}} - nazwa jednostki (strony), tzn. jego adres, * {{Code|czy_naprawiaj}} (parametr funkcji), {{Code|2}} lub {{Code|czy naprawiać}} - znaczą to samo, co pierwszy parametr w tym wierszu, który jest parametrem funkcji. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}}, {{Code|strona}} lub {{Code|nazwa jednostki}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona="https://pl.wikibooks.org/wiki/Strona ___ główna ? action____=____edit ____&____ section = 2 # ____ Nagłówek____________strony "; local tabela_nazw_adresu={}; -- Równoważne: local parametry=html_modul["PoprawAdresNagłówkaOrazParametrówStronyAdresu"](strona,true,tabela_nazw_adresu); local adres=html_modul["PoprawAdresNagłówkaOrazParametrówStronyAdresu"]({strona=strona,["czy naprawiać"]=true,},nil,tabela_nazw_adresu); </syntaxhighlight> Wartość pełnego adresu strony poprawiona jest w zmiennej: <syntaxhighlight lang="lua"> -- Wydzielono z pełnego adresu strony adres, parametry i nagłówek, naprawione i złączone ze sobą w pełny poprawiony adres; local adres="https://pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; </syntaxhighlight> == {{Code|p.URLStrona(frame)}} == Funkcja z adresu '''URL''' wydziela nazwę serwera i nazwę strony. On nie może zawierać w sobie protokołu, tylko musi zaczynać od {{Code|<nowiki>//</nowiki>}}. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.URLStrona(frame)...end; </syntaxhighlight> Parametry ramki: * {{Code|1}} lub {{Code|url}} - adres strony, * {{Code|2}} lub {{Code|ukośnik}} - czy do nazwy strony ma wliczać ukośnik. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"): local url="//pl.wikibooks.org/wiki/Strona_artykułu"; local serwer,nazwa=html_modul.URLStrona{url=url,["ukośnik"]=true,}; </syntaxhighlight> Wartości zmiennych kryją się pod: <syntaxhighlight lang="lua"> -- Widzimy, że nazwa serwera jest bez prawych ukośników; local serwer="pl.wikibooks.org"; -- Nazwa strony zaczyna się bez ukośnika, bo powiedzieliśmy funkcji, by nie brał prawych ukośników, które są na początku nazwy strony, bez nazwy serwera i protokołu, ale w sobie może mieć on, ale nie musi; local nazwa="wiki/Strona_artykułu"; -- Gdyby było ["ukośnik"]=false, to wtedy otrzymalibyśmy inny wynik, czyli: local nazwa="/wiki/Strona_artykułu"; </syntaxhighlight> == {{Code|p["UrlBezProtokołu"](frame)}} == Funkcja adresowi z protokołem usuwa to właśnie, a jak podamy adres „mail”, to podaje nazwę tego adresu, bez niego. Drugą zwracaną nazwą jest nazwa protokołu,a jak się nie da go wyznaczyć, to funkcja zwraca wartość {{Code|nil}}. Trzecia wartość, to numer sposoby, a jeżeli żaden sposób nie pasuje, to ta wartość jest {{Code|-1}}, a gdy adres mail {{Code|1}}, dla adresu z protokołem {{Code|2}}, a dla adresu bez protokołu {{Code|3}}. Funkcja do zbierania parametrów ramki {{Code|frame}} używa funkcji: {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Parametry}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["UrlBezProtokołu"]=function(frame)...end; </syntaxhighlight> Parametry ramki: * {{Code|1}} lub {{Code|url}} - adres strony, ewentualnie z opcjonalnym protokołem. Kolejność ważności parametrów ramki jest, w jakiej kolejności są brane parametry, są w kolejności, w jakim te one przedstawiono. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|1}} lub {{Code|url}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local mail="użytkownik@skrzynka.org"; -- Równoważnie: local adres1,protokol1,sposob1=html_modul["UrlBezProtokołu"](mail); local adres1,protokol1,sposob1=html_modul["UrlBezProtokołu"]{url=mail,}; --- local url="https://pl.wikibooks.org/wiki/Strona"; -- Równoważnie: local adres2,protokol2,sposob2=html_modul["UrlBezProtokołu"](url); local adres2,protokol2,sposob2=html_modul["UrlBezProtokołu"]{url=url,}; --- local url="//pl.wikibooks.org/wiki/Strona"; -- Równoważnie: local adres3,protokol3,sposob3=html_modul["UrlBezProtokołu"](url); local adres3,protokol3,sposob3=html_modul["UrlBezProtokołu"]{url=url,}; --- local url="pl.wikibooks.org/wiki/Strona"; -- Równoważnie: local adres4,protokol4,sposob4=html_modul["UrlBezProtokołu"](url); local adres4,protokol4,sposob4=html_modul["UrlBezProtokołu"]{url=url,}; </syntaxhighlight> Wyniki otrzymane z powyższych przykładów są: <syntaxhighlight lang="lua"> local adres1,protokol1,sposob1="//skrzynka.org","mail",1; local adres2,protokol2,sposob2="//pl.wikibooks.org/wiki/Strona","https",2; local adres3,protokol3,sposob3="//pl.wikibooks.org/wiki/Strona",nil,3; local adres4,protokol4,sposob4="//pl.wikibooks.org/wiki/Strona",nil,-1; </syntaxhighlight> == {{Code|p.DecodeKoduHTMLZnaku(tekst)}} == Zamienia kody {{Strong|HTML}}, tzn. literowe (ogólny wzór {{Code|<nowiki>&(%a+);</nowiki>}}), dziesiętne (ogólny wzór {{Code|<nowiki>&#(%d+);</nowiki>}}) i szesnastkowe (ogólny wzór {{Code|<nowiki>&#x(%x+);</nowiki>}}) na odpowiednie znaki. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeKoduHTMLZnaku(tekst)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tekst}} - tekst do zamienienia z dziesiętnymi, szesnastkowymi i literowymi kodami {{Strong|HTML}} na odpowiednie znaki. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst z kodami HTML: literowymi, dziesiętnymi i szesnastkowymi; local tekst="Oto jest link: &#x5B;&#x5B;Strona&#124;Nazwa linku&#93;&#x5D;, a w nim spacje niełamliwe&nbsp;i inne znaki: z alfabetu greckiego jak: &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;"; -- Wywołanie funkcji odkodujący kody HTML; local tekst2=html_modul.DecodeKoduHTMLZnaku(tekst); </syntaxhighlight> Otrzymany wynik jest pod zmienną: <syntaxhighlight lang="lua"> -- Widzimy, że tekst został zdekodowany ze znaków HTML; local tekst2="Oto jest link: [[Strona|Nazwa linku]], a w nim spacje niełamliwe i inne znaki: z alfabetu greckiego jak: αΑβΒγΓδΔεΕζΖηΗθΘιΙκΚλΛμΜνΝξΞοΟπΠρΡσΣτΤυΥφΦχΧψΨωΩ"; </syntaxhighlight> == {{Code|p.ZamianaEncodeTekst(tekst)}} == Adres strony dekoduje funkcją: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, następnie koduje, jeszcze więcej niż było na samym początku, według: {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaEncodeTekst(tekst)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tekst}} - tekst do odkodowania i zakodowania jeszcze więcej niż było na początku zakodowane. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local tekst="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; local tekst2=html_modul.ZamianaEncodeTekst(tekst); </syntaxhighlight> Wynikiem funkcji, co kryje się pod zmienną {{Code|tekst2}}: <syntaxhighlight lang="lua"> local tekst2="https%3A%2F%2Fpl.wikibooks.org%2Fw%2Findex.php%3Ftitle%3DSzablon%3ALink_wewn%C4%99trzny%26action%3Dedit%23Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)}} == Funkcja wyszukuje tekst do zamiany i działa na niego funkcją: {{Code|{{sr|#p.ZamianaEncodeTekst(tekst)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)...end; </syntaxhighlight> Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Tekst nie do końca zakodowany wydzielonego według poniższego wzoru; local tekst="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obsługa"; -- Wzór, który wydziela części do kodowania jeszcze bardziej niż były na samym początku; local wzor="[^/%?%=&:%#]+"; -- Wywołanie funkcji kodującej; local tekst2=html_modul.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor); </syntaxhighlight> Wynikiem funkcji, co kryje się pod zmienną {{Code|tekst2:}} <syntaxhighlight lang="lua"> -- Zakodowało jeszcze więcej niż na samym początku było zakodowane; local tekst2="https://pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.StronaParametryIdentyfikacjaAdresuHtml(adres)}} == Funkcja z całkowitego adresu składający się z adresu właściwego, parametrów i nagłówka, rozdzielane jest na trzy części, z których się składa. Funkcja sprawdza, czy jakikolwiek kody {{Strong|HTML}} występują w pełnym adresie strony, jeżeli są to przedtem koduje jeszcze lepiej kody znaków {{Code|<nowiki>#</nowiki>}}, przy pomocy funkcji: {{Code|{{sr|#p.EncodeHashKoduHtmlTekstu(tekst)|p=Html}}}}, a później w kodach {{Strong|HTML}} znak {{Code|<nowiki>#</nowiki>}} jest zamieniany na kod literowy {{Strong|HTML}}, czyli: {{Code|{{Nowiki|&num;}}}}, funkcją: {{Code|{{sr|#p.EncodeTempHashKoduHtmlTekstu(tekst)|p=Html}}}} (jeżeli w adresie kody istnieją), wtedy cos powstaje w rodzaju dla kodu dziesietnego: {{Code|<nowiki>&&num;(%d+);</nowiki>}}, i szesnastkowego: {{Code|<nowiki>&&num;x(%x+);</nowiki>}} - gdzie w nich {{Code|<nowiki>#</nowiki>}} został zamieniony na {{Code|{{Nowiki|&num;}}}}, które są przedstawione według wyrażeń regularnych {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. Funkcja rozdziela to na trzy części, a później odkodowuje każdą część funkcją: {{Code|{{sr|#p.DecodeTempHashKoduHtmlTekstu(tekst,...)|p=Html}}}} (jeżeli w adresie kody w ogóle istniały), i podobnie później: {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}} (jeżeli kody znaku: {{Code|<nowiki>#</nowiki>}}, były wcześniej). Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.StronaParametryIdentyfikacjaAdresuHtml(adres)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - adres do potrzelenia na trzy części. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="https://pl.wikibooks.org/wiki/Strona&#32;główna&num;&#x23;&#35;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; -- Adresstrony jedynie rozkładaa się na: "strona", "parametry" i "nagłówek"; local strona,parametry,naglowek=html_modul.StronaParametryIdentyfikacjaAdresuHtml(adres); </syntaxhighlight> Otrzymane wartości tych zmiennych kryją się pod adresami: <syntaxhighlight lang="lua"> local strona,parametry,naglowek="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#35;To_nie_jest nagłówek","action=edit&section=2","Nagłówek strony",3; </syntaxhighlight> Funkcja zwraca trzy wartości, tzn. adres właściwy (bez parametrów i nagłówka), parametry (używane jako dodatek do adresów przy formułowaniu formularzy) i nagłówek (który jest adresem na stronie do odpowiedniego elementu o danym atrybucie: {{Code|id}}). == {{Code|p.TworzenieAdresuHtml(strona,...)}} == Funkcja łączy, stronę, parametry i nagłówek strony, w pełną nazwę strony (adresu), dalej jest uruchamiana funkcja ddekodująca ciagi znakowe: {{Code|{{Nowiki|&amp;&num;}}}}. Funkcja wykorzystuje do dekodowania tego {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TworzenieAdresuHtml(strona,parametry,naglowek)...end; </syntaxhighlight> Parametry funkcji: * {{Code|strona}} - nromalny adres strony, bez parametrów i nagłówka, * {{Code|parametry}} - parametry strony w formacie {{Code|nazwa{{=}}wartość}} oddzielone od siebie znakiem {{Code|<nowiki>&</nowiki>}}, * {{Code|nagłówek}} - nagłówek linkujący do {{Code|id}} jakiegos elementyna stronie, Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local strona,parametry,naglowek,ile="https://pl.wikibooks.org/wiki/Strona&#32;główna&num;&#35;&#x23;To_nie_jest nagłówek","action=edit&section=2","Nagłówek strony",3; local adres=html_modul.TworzenieAdresuHtml(strona,parametry,naglowek); </syntaxhighlight> Otrzymany pełny pojedynczy adres strony, z normalnym adresem strony z parametrami i nagłówkiem, jest ukryta: <syntaxhighlight lang="lua"> local adres="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#35;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; </syntaxhighlight> Funkcja zwraca całkowity adres z adresem właściwym, parametrami (po {{Code|<nowiki>?</nowiki>}}, jeżeli po nim występują wartości przyrównane nazwą zmiennych {{Strong|HTML}}) i nagłówkiem (po {{Code|<nowiki>#</nowiki>}}). == {{Code|p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)}} == Pełny adres strony, bezprotokolarny (lub protokolarny, jeżeli rozdzielimy, w pierwszej funkcji anonimowej w tej nagłówku, na protokół i adres bezprotokolarny, czyli na dwie części, zrobimy operacje, a później je złączymy w nim), linków zewnętrznych lub wewnętrznych, z adresem właściwym, parametrami i nagłówkiem strony, po podziale na je trzy części funkcją {{Code|{{sr|#p.StronaParametryIdentyfikacjaAdresuHtml(adres)|p=Html}}}}, następnie na każdą z tych elementów działamy odpowiednimi funkcjami, a potem ich wyniki łączymy w pełny adres strony funkcją {{Code|{{sr|#p.TworzenieAdresuHtml(strona,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,funkcja_strona,funkcja_parametry,funkcja_naglowek)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - pełny adres do przetworzenia, * {{Code|funkcja_strona}} - funkcja, którą działamy na właściwy adres strony, bez parametrów i nagłówka, * {{Code|funkcja_parametry}} - funkcja, którą działamy na parametry adresu strony, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek strony adresu. Przykład takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local function ParametryEncodeURL(a,b,c) return a..html_modul.ZamianaEncodeTekst(b).."="..html_modul.ZamianaEncodeTekst(c); end; local function OperacjeHtml(adres) adres=mw.ustring.gsub(adres,"^(%??)([^&=]*)=([^&]*)",ParametryEncodeURL); adres=mw.ustring.gsub(adres,"(&)([^&=]*)=([^&]*)",ParametryEncodeURL); return adres; end; return html_modul.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres, -- Funkcja: funkcja_strona; function(strona) strona=html_modul.ZamianaEncodeNaPodstawieWzoruTekstu(strona,"[^/]+"); return strona; end, -- Funkcja: funkcja_parametry; OperacjeHtml, -- Funkcja: funkcja_naglowek; function(naglowek) naglowek=html_modul.ZamianaEncodeTekst(naglowek); return naglowek; end ); </syntaxhighlight> == {{Code|p.ParametryEncodeURL(adres,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.ZamianaEncodeTekst(tekst)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p.ParametryEncodeURL(adres,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="//pl.wikibooks.org/w/index.php?title=Szablon:Link_wewn%C4%99trzny&action=edit#Obsługa"; local adres2=html_modul.ParametryEncodeURL(adres,true, function(strona) strona=html_modul.ZamianaEncodeNaPodstawieWzoruTekstu(strona,"[^/]+"); return strona; end, function(naglowek) naglowek=html_modul.ZamianaEncodeTekst(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="//pl.wikibooks.org/w/index.php?title=Szablon%3ALink_wewn%C4%99trzny&action=edit#Obs%C5%82uga"; </syntaxhighlight> == {{Code|p.ParametryZaawansowanyEncodeURL(adres,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}, ale przed nim wywoływana ajest funkcja {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a po nim {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.ParametryZaawansowanyEncodeURL(adres,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.ParametryZaawansowanyEncodeURL(adres,true, function(strona) strona=mw.uri.decode(strona); strona=html_modul.EncodeSpecjalneZnakiHtml(strona); strona=mw.uri.encode(strona); return strona; end, function(naglowek) naglowek=mw.uri.decode(naglowek); naglowek=html_modul.EncodeSpecjalneZnakiHtml(naglowek); naglowek=mw.uri.encode(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="Szablon%3ALink_wewn%C4%99trzny?action=edit#Obs%C5%82uga%26%2363%3B"; </syntaxhighlight> == {{Code|p.EncodeParametryHtml(parametr,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.EncodeHtml(...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeParametryHtml(parametr,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.EncodeParametryHtml(adres,true, function(strona) strona=html_modul.EncodeHtml(strona); return strona; end, function(naglowek) naglowek=html_modul.EncodeHtml(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="Szablon:Link_wewn%C4%99trzny?action=edit#Obs%C5%82uga%3F"; </syntaxhighlight> == {{Code|p.EncodeZaawansowanyParametryHtml(adres,...)}} == Funkcja przystosowana do analizy adresu, tzn. przede wszystkim adresów bezprotokolarnych (lub protokolarnych, jeżeli rozdzielimy to na protokół i adres bezprotokolarny, czyli na dwie części, według pierwszej funkcji w tym nagłówku, zrobimy operacje, a później je złączymy) linków zewnętrznych i wewnętrznych, pełnego strony ze specjalistycznym analizatorem parametrów adresu, funkcja właściwy adres strony i nagłówek działa odpowiednimi funkcjami. Funkcja wykorzystuje lub nie, ale ma to w definicji, funkcję {{Code|{{sr|#p.TworzenieStronaParametryIdentyfikacjaAdresuHtml(adres,...)|p=Html}}}}. Funkcja też może też służyć do analizy tylko parametrów, jeżeli drugi parametr jest {{Code|false}} lub {{Code|nil}}, a jeżeli wartość odpowiada wartości logicznej {{Code|true}}, to trzeba rozpatrywać pełne adresy stron protokolarne, czy nie, omówione na początku w tym rozdziale. Przy analizie nazw i wartości parametrów wykorzystuje {{Code|{{sr|#p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)|p=Html}}}}, a przed nim wywoływana jest {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a po nim jeżeli jest włączone kodowanie w zmiennej drugiej funkcji, wtedy {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeZaawansowanyParametryHtml(adres,z_kodowaniem,w_adresie,funkcja_strona,funkcja_naglowek)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - pełny adres strony z parametrami i nagłówkiem, * {{Code|z_kodowaniem}} - czy ostateczny nagłówek ma być zakodowany, * {{Code|w_adresie}} - czy rozpatrywać cały adres, a nie tylko parametry, * {{Code|funkcja_strona}} - funkcja, którą działamy na adres właściwy strony, bez parametrów i nagłówka, * {{Code|funkcja_naglowek}} - funkcja, którą działamy na nagłówek. Przykłady takiego wywołania: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.EncodeZaawansowanyParametryHtml(adres,true,true, function(strona) strona=mw.uri.decode(strona); strona=html_modul.EncodePodstawoweHtmlTekstu(strona); strona=mw.uri.encode(strona); return strona; end, function(naglowek) naglowek=mw.uri.decode(naglowek); naglowek=html_modul.EncodePodstawoweHtmlTekstu(naglowek); naglowek=mw.uri.encode(naglowek); return naglowek; end); </syntaxhighlight> Wartość zmiennej {{Code|adres2}} jest w wartości: <syntaxhighlight lang="lua"> local adres2="Szablon%3ALink_wewn%C4%99trzny?action=edit#Obs%C5%82uga%26%2363%3B"; </syntaxhighlight> == {{Code|p.EncodeHashKoduHtmlTekstu(tekst)}} == Funkcja koduje kod {{Strong|HTML}} znaku {{Code|<nowiki>#</nowiki>}}, czyli {{Code|{{Nowiki|&num;}}}}, {{Code|{{Nowiki|&#35;}}}} i {{Code|{{Nowiki|&#x23;}}}}. Te wszystkie kody funkcja zamienia je z każdnych na kod: {{Code|{{Nowiki|&amp;num;}}}}. Funkcja zwraca przetworzony tekst, ze zmienną {{Code|ile}} mówiącej ile jest możliwych kodów na stronie, także z {{Code|ile2}} wskazującej, ile jest kodów na stronie rozwazanego znaku. Funkcja używana, gdy nie chcemy, by dodatkowe znaki {{Code|<nowiki>#</nowiki>}} przeskadzały na rozkład adresu strony na właściwy adres, parametry i nagłówek strony, co po rozkładzie wywoływana jest jego też jego funkcja odwrotna {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}}, a tak powstałe znaki {{Code|{{Nowiki|&#35;}}}} ze wszystkich tych kodów {{Code|<nowiki>#</nowiki>}} według pewnych funkcji modułu {{Code|{{ld2|Html}}}}, że one nie zostaną odkodowane, bo są one pomijane. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeHashKoduHtmlTekstu(tekst)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tekst}} - tekst do przetworzenia. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Kody do zamienienia local tekst="&num;, &#35; i &#x23;"; -- Przetwarzanie tekstu local tekst2,ile,ile2=html_modul.EncodeHashKoduHtmlTekstu(tekst); </syntaxhighlight> Wynik jest pod zmienną: <syntaxhighlight lang="lua"> -- Wszystkie możliwe warianty funkcja zamieniła na to samo, czyli na: "&amp;num;" kodu HTML "&num;" dla znaku "#"; local tekst2,ile,ile2="&amp;num;, &amp;num; i &amp;num;",3,3; </syntaxhighlight> == {{Code|p.DecodeHashKoduHtmlTekstu(tekst,ile)}} == Jeżeli dokonano zamiany możliwych kodów {{Code|{{Nowiki|&num;}}}}, {{Code|{{Nowiki|&#35;}}}} i {{Code|{{Nowiki|&#x23;}}}} na {{Code|{{Nowiki|&num;num}}}}, wtedy druga zmienna jest większa od zera, wtedy możliwa jest tego zamiana na kod {{Code|{{Nowiki|&#35;}}}} kodu {{Code|{{Nowiki|&num;num}}}}, używając tej funkcji. Funkcja używana, gdy właściwy adres, parametry i nagłówek strony zostały po rozłączeniu na te części z pełnego adresu strony, wraz z innymi funkcjami odkodowującymi znaki niektóre {{Strong|HTML}}, oraz jeżeli ciało jej wersji prostej została wywołana wcześniej. Jest to odwrotność funkcji {{Code|{{sr|#p.EncodeHashKoduHtmlTekstu(tekst)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeHashKoduHtmlTekstu(tekst,ile)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tekst}} - tekst do przetworzenia, * {{Code|ile}} - {{Code|<nowiki>ile>0</nowiki>}}, jeżeli dokonano możliwych zamian kodów znaku {{Code|<nowiki>#</nowiki>}} na {{Code|{{Nowiki|&num;num}}}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Zamienione wcześniej kody: tekstu "&num;, &#35; i &#x23;", kolejno na "&amp;num;"; local tekst="&amp;num;, &amp;num; i &amp;num;"; -- Odkodowanie znaków "&amp;num;" w tekście; local tekst2=html_modul.DecodeHashKoduHtmlTekstu(tekst,3); </syntaxhighlight> Wynik jest ukryty pod zmienną: <syntaxhighlight lang="lua"> local tekst2="&#35;, &#35; i &#35;"; </syntaxhighlight> == {{Code|p.EncodeTempHashKoduHtmlTekstu(tekst)}} == Jeżeli mamy jakieś kody {{Strong|HTML}}, to aby one nie przeszkadzały w rozkładzie na właściwy adres, parametry i nagłówek strony, to te tam {{Code|<nowiki>#</nowiki>}} należy zamienić na {{Code|{{Nowiki|&num;}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeTempHashKoduHtmlTekstu(tekst)...end; </syntaxhighlight> Parametry funkcji: * {{Code|tekst}} - tekst do przetworzenia. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Mamy tutaj kody HTML znaku: "#", czyli: "&#35;" i "&#x23;" oraz jeden od spacji: "&#32;";, a tam "#"zamieniamy na "&num;"; local tekst="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; -- Otrzymamy przetworzony tekst oraz ile uzyskamy znaków z kodem HTML dziesiętnym "ile1" i szesnastkowym "ile2"; local tekst2,ile1,ile2=html_modul.EncodeTempHashKoduHtmlTekstu(tekst); </syntaxhighlight> Wynik tego jest pod zmienną: <syntaxhighlight lang="lua"> local tekst2,ile1,ile2="https://pl.wikibooks.org/wiki/Strona&&num;32;główna&&num;35;&&num;35;&&num;x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony",3,1; </syntaxhighlight> == {{Code|p.DecodeTempHashKoduHtmlTekstu(tekst,...)}} == Jeżeli mamy jakieś kody {{Strong|HTML}}, to aby one nie przeszkadzały w rozkładzie na właściwy adres, parametry i nagłówek strony, to te tam {{Code|<nowiki>#</nowiki>}} należy zamienić na {{Code|{{Nowiki|&num;}}}}. One tak zostały zamienione funkcją {{Code|{{sr|#p.EncodeTempHashKoduHtmlTekstu(tekst)|p=Html}}}}. Po rozłożeniu na trzy części pełnego adresu strony, tzn. na właściwy adres, parametry i nagłówek strony, możemy wywołać dla każdej z nich tę funkcję, wykonując operację odwrotną. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.DecodeTempHashKoduHtmlTekstu(tekst,ile1,ile2)...end; </syntaxhighlight> Parametry zwykłe funkcji: * {{Code|tekst}} - tekst do przetworzenia i po rozdzieleniu na trzy części, * {{Code|ile1}} - ile jest przetworzonych kodów dziesietnych prez funkcje do rozważanej prostej, * {{Code|ile2}} - ile jest przetworzonych kodów szesnastkowych przez funkcją do rozważanej prostej. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Mamy tutaj kody HTML znaku: "#", czyli: "&&num;35;" i "&&num;x23;" oraz jeden od spacji: "&&num;32;";, a tam "#"zamieniamy na "&num;"; local tekst="https://pl.wikibooks.org/wiki/Strona&&num;32;główna&&num;35;&&num;35;&&num;x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; -- Otrzymamy przetworzony tekst, do którego wsadzamy ile uzyskamy znaków z kodem HTML dziesiętnym "ile1" i szesnastkowym "ile2" w wywołaniu local tekst,ile1,ile2=p.EncodeTempHashKoduHtmlTekstu(tekst); local tekst2=html_modul.EncodeTempHashKoduHtmlTekstu(tekst,3,1); </syntaxhighlight> Wynik tego jest pod zmienną: <syntaxhighlight lang="lua"> local tekst2="https://pl.wikibooks.org/wiki/Strona&#32;główna&#35;&#35;&#x23;To_nie_jest nagłówek?action=edit&section=2#Nagłówek strony"; </syntaxhighlight> == {{Code|p.AdresDomniemanieBezProtokolarnyEncodeURL(adres,...)}} == Funkcja domyślnie koduje adres bezprotokolarny, a z podaniem drugiej wartości {{Code|true}} protokolarny. Funkcja wykorzystuje funkcję {{Code|{{sr|#p.ZamianaEncodeNaPodstawieWzoruTekstu(tekst,wzor)|p=Html}}}}. A jeżeli druga wartość odpowiada prawdziwości, to korzystamy z {{Code|{{sr|#p["UrlBezProtokołu"](frame)|p=Html}}}} na rozkład na adres bezprotokolarny i protokół. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.AdresDomniemanieBezProtokolarnyEncodeURL(adres,protokolarny)...end; </syntaxhighlight> Parametry funkcji: * {{Code|adres}} - adres do zakodowania, * {{Code|protokolarny}} - czy ma rozkładać adres na nazwę strony i protokół. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Adres protokonalny; local adres11="https://pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; local adres12=html_modul.AdresDomniemanieBezProtokolarnyEncodeURL(adres11,true); -- Adres bezprotokonalny; local adres21="//pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; local adres22=html_modul.AdresDomniemanieBezProtokolarnyEncodeURL(adres21,false); </syntaxhighlight> Wynik wartości {{Code|adres12}} i {{Code|adres12}} jest: <syntaxhighlight lang="lua"> -- Zakodowany adres z protokołem local adres12="https://pl.wikibooks.org/wiki/Strona_g%C5%82%C3%B3wna?action=edit&section=2#Nag%C5%82%C3%B3wek%20strony"; -- Zakodowany adres bez protokołu local adres22="//pl.wikibooks.org/wiki/Strona_g%C5%82%C3%B3wna?action=edit&section=2#Nag%C5%82%C3%B3wek%20strony"; </syntaxhighlight> == {{Code|p.UriEncode(frame)}} == Funkcja do kodowania adresów tylko z protokołem, wartości bez protokołu nie obsługuje. Wykorzystuje {{Code|{{sr|#p.AdresDomniemanieBezProtokolarnyEncodeURL(adres,...)|p=Html}}}}. Do wyszukiwania adresów jest brana funkcja {{Code|{{sr|#p.PobierzParametr(frame,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.UriEncode(frame)...end; </syntaxhighlight> Parametry tablicy ramki tablicy transportu: * {{Code|html}} - adres z protokołem strony. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|html}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); -- Adres protokonalny; local adres="https://pl.wikibooks.org/wiki/Strona_główna?action=edit&section=2#Nagłówek strony"; -- Równoważnie: local adres2=html_modul.UriEncode{html=adres,}; local adres2=html_modul.UriEncode(adres); </syntaxhighlight> Wynik jest w zmiennej: <syntaxhighlight lang="lua"> local adres2="https://pl.wikibooks.org/wiki/Strona_g%C5%82%C3%B3wna?action=edit&section=2#Nag%C5%82%C3%B3wek%20strony"; </syntaxhighlight> == {{Code|p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)}} == Funkcja blokuje odkodowywanie możliwych kodów {{Strong|HTML}} znaku {{Code|<nowiki>#</nowiki>}}, w tym celu wywoływana jest funkcja: {{Code|{{sr|#p.KodowanieOmijanieFunkcyjne(html,...)|p=Html}}}}, do omijania tego znaku, funkcja omija tylko znaki zapisane w kodach {{Strong|HTML}}, tzn. {{Code|{{Nowiki|&#35}}}}, w tym celu wszystkie kody tego znaku zamieniamy na jeden, przed wywołaniem tej funkcji, funkcjami: {{Code|{{sr|#p.EncodeHashKoduHtmlTekstu(tekst)|p=Html}}}} i {{Code|{{sr|#p.DecodeHashKoduHtmlTekstu(tekst,ile)|p=Html}}}}. Ta funkcja w pierwszym kroku, w nim we wspomnianej funkcji wywołanej w funkcji anonimowej, wywołuje funkcję dekodujące znaki, czyli: {{Code|{{sr|#p.DecodeKoduHTMLZnaku(tekst)|p=Html}}}}, do odkodowania kodów, {{Strong|HTML}}, dziesiętnych, szesnastkowych i literowych. Na samym końcu kodowane są specjalne znaki na podstawie: {{Code|{{sr|#p.EncodeSpecjalneZnakiHtml(frame,...)|p=Html}}}}, na kody {{Strong|HTML}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)...end; </syntaxhighlight> Parametry funkcji: * {{Code|elementy_adresu_strony}} - funkcja do podstawowego kodowania adresu. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="Szablon:Link_wewnętrzny?action=edit#Obsługa?"; local adres2=html_modul.EncodePodstawoweHtmlTekstu(adres); </syntaxhighlight> Wartość zmiennej jest ukryta pod: <syntaxhighlight lang="lua"> local adres2="Szablon:Link_wewnętrzny&#63;action&#61;edit&#35;Obsługa&#63;"; </syntaxhighlight> == {{Code|p.EncodeElementyAdresuStrony(elementy_adresu_strony,...)}} == Gdy mamy problem (przypadek) z parametrami adresu strony,wtedy do kodowania wywoływana jest funkcja {{Code|{{sr|#p.EncodeZaawansowanyParametryHtml(adres,...)|p=Html}}}}, a gdy posługujemy się właściwym adresem strony lub nagłówkiem, wtedy dekodujemy '''URL''' funkcją {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, następnie {{Code|{{sr|#p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)|p=Html}}}}, i jeżeli mały włączone kodowanie, następnie {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.EncodeElementyAdresuStrony(elementy_adresu_strony,czy_parametry_strony,z_kodowaniem)...end; </syntaxhighlight> Parametry funkcji: * {{Code|elementy_adresu_strony}} - element adresu strony, * {{Code|czy_parametry_strony}} - czy parametry strony rozważać, jako że wtedy jest taki adres jako parametry, * {{Code|z_kodowaniem}} - czy jest włączone kodowanie funkcji po odkodowaniu i pewnych operacjach w tej funkcji. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local elementy_adresu_strony="Obsługa?"; local elementy_adresu_strony2=html_modul.EncodeElementyAdresuStrony(elementy_adresu_strony,false,true); </syntaxhighlight> Wartość zmiennej jest ukryta pod: <syntaxhighlight lang="lua"> local elementy_adresu_strony2="Obs%C5%82uga%26%2363%3B"; </syntaxhighlight> == {{Code|p.AdresProjektuEncodeHtml(frame,...)}} == Funkcja korzysta do dekodowania na samym początku '''URL''' {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.decode|n=mw.uri.decode}}}}, a na końcu {{Code|{{lz|s=https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual/pl|g=mw.uri.encode|n=mw.uri.encode}}}}, jeżeli jest włączone kodowanie, między czasie korzysta z {{Code|{{sr|#p.EncodePodstawoweHtmlTekstu(elementy_adresu_strony)|p=Html}}}}. Główny elementem funkcyjnym jest {{Code|{{sr|#p.EncodeZaawansowanyParametryHtml(adres,...)|p=Html}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> function p.AdresProjektuEncodeHtml(frame,z_kodowaniem,protokolarny)...end; </syntaxhighlight> Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|z_kodowaniem}} - czy końcowo kodować, * {{Code|protokolarny}} - czy uważać przy kodowaniu na protokoły pełnych adresów stron. Parametry tablicy ramki tabeli transportu: * {{Code|html}} - adres do kodowania, * {{Code|encode}} - czy kodować. Jeżeli zawartością jednego parametru funkcji nie jest ramka, tylko inny parametr, który jest tekstem, wtedy to jest ten sam parametr, co {{Code|html}}. Przykłady użycia: <syntaxhighlight lang="lua"> local html_modul=require("Module:Html"); local adres="https://pl.wikibooks.org/wiki/Strona_&główna?&?action=edit&section=2&title=Nazwa strony szablonu: {{!}}#Nagłówek strony"; local adres2=html_modul.AdresProjektuEncodeHtml(adres,false,true); local adres3=html_modul.AdresProjektuEncodeHtml(adres,true,true); </syntaxhighlight> Wartość zmiennej jest ukryta pod: <syntaxhighlight lang="lua"> local adres2="https://pl.wikibooks.org/wiki/Strona_&#38;główna&#63;&#38;?action=edit&section=2&title=Nazwa strony szablonu: &#123;&#123;!&#125;&#125;#Nagłówek strony"; local adres3="https://pl.wikibooks.org/wiki/Strona_%26%2338%3Bg%C5%82%C3%B3wna%26%2363%3B%26%2338%3B?action=edit&section=2&title=Nazwa%20strony%20szablonu%3A%20%26%23123%3B%26%23123%3B%21%26%23125%3B%26%23125%3B#Nag%C5%82%C3%B3wek%20strony"; </syntaxhighlight> {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> 0ytfh4t33powuqzb732rfkommrfp1os 4 63486 541359 541160 2026-04-30T08:59:54Z Persino 2851 /* Funkcje nazw przestrzeni nazw i pełnych nazw jednostek, ich parametry */ 541359 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Pudełko}}|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 pudelko_modul=require("Module:Pudełko"); </syntaxhighlight> dzięki, któremu można wypisywać funkcje należącego do niego. == Opis podstawowy parametrów pudełek == Do tego rozdziału potrzebne są wiadomości z: * {{sr|#Parametry bazowe i numerkowe|p=Pudełko}}, * {{sr|#Tworzenie typów jednostek dyskusji i rodzina parametrów dyskusja typu jednostki|p=Pudełko}}, * {{sr|#Typy jednostek i odpowiadające im nazwy przedmiotowe przestrzeni nazw|p=Pudełko}}, * {{sr|#Parametry dodatkowe typów jednostek|p=Pudełko}}. Moduł {{Code|{{ld2|Pudełko}}}} przedstawia funkcje nazw w oparciu o funkcje nazw {{Code|{{ld2|Nazwy}}}}, generuje on nazwy za pomocą parametrów pudełkowych podanych poniżej. Te funkcje liczą na podstawie zmiennych: : Posługuje się na parametrach pudełkowych {{Parametr|nazwa przestrzeni nazw}} (czy też bez numerka {{Parametr|nazwa przestrzeni nazw i}} dla tego numerowanego) lub te z numerkiem po jednej spacji w nich (ale nie dla tego z końcówką {{Code| i}}) są to parametry nazw przestrzeni nazw dla różnych numerków lub bez numerka. : Parametr {{Parametr|nazwa jednostki}} (lub parametr {{Parametr|cel}} dla numerka tego pierwszego, tego alternatywnego), lub te z numerkiem po jednej spacji w nazwie parametru, albo numerowane numerkami {{Code|1}}, {{Code|2}},..., mogą zostać użyte jako parametry szablonu. Te parametry nienazwane i {{Code|cel}} {{=}} {{Code|1}}, są to parametry nazw jednostek, bez przestrzeni nazw, ale nie zawsze, bo jak czasami przestrzeń nazw jest pusta (bo wskazuje na przestrzeń główną lub ewentualnie jest „Dyskusja” przy funkcjach przedmiotowych pudełek), wtedy liczy się nazwa przestrzeni nazw z nazwy jednostek. Wtedy nazwa przestrzeni nazw jest z tego liczona, a nazwa jednostki po usunięciu przestrzeni nazw z niego. : Parametry określające rodzaj jednostki {{Parametr|typ jednostki}} z {{Parametr|dyskusja typu jednostki}}, i nie tylko, itp. w wersjach z numerkiem po jednej spacji w nich mogą zostać użyte jako parametry szablonu. Też jest ich wersja z {{Code|i}} po spacji w tych parametrach podstawowych. Ten parametr wskazuje na odpowiednią przestrzeń policzaną bezpośrednio z niego, lub jest przedstawiana w postaci też przedmiotowej lub dyskusji przy funkcjach tego dotyczących. Ten parametr obrazuje przestrzenie nazw przedmiotowe lub dyskusji, a jeżeli mamy typ jednostki przedmiotowy, wskazujący na porzestrzeń przedmiotową, z wartoscią niepustą dyskusji typu jednostek, wtedy to, jako całość, wskazujena orzestrzeń dyskusji, w przeciwnym wypadku,nie zawsze tak jest. : A te tymi numerowanymi liczbami naturalnymi {{Tt|nazwy jednostki}} od jedynki wzwyż poprzez szablon, w którym są one użyte, one też mogą być użyte z dwukropkiem, te numerowane, na samym początku nazwy, wtedy one są traktowane jako pełne nazwy strony, i wtedy one nie zostaną z interpretowane, że do nich trzeba użyć parametr odpowiedni z nazwą przetrzeni nazw z tego numerowanego, czy ogólny, aby utworzyć znów inną pełną nazwę strony dla tego numerka,tak jest przy wersjach funkcji pudełkowych w wersjach dwa i trzy, a dla wersji dwa, również to dotyczy parametrów bazowych. === Zestawienie: === * {{Code|nazwa przestrzeni nazw}} i {{Code|nazwa przestrzeni nazw i}} (ogólna nazwa przestrzeni nazw dla wszystkich numerków, i tych numerowanych jednostek) - i to pierwsze z numerkiem, tzn. {{Code|nazwa przestrzeni nazw 1}}, {{Code|nazwa przestrzeni nazw 2}}, ..., * {{Code|nazwa jednostki}} - i te z numerkiem: {{Code|nazwa jednostki 1}}, {{Code|nazwa jednostki 2}}, ..., lub gdy jest zamiast tego parametry numerowane, podawane tylko w ramce szablonu rodzica, w postaci zmiennych nienazwanych: {{Code|1}}, {{Code|2}},..., który dla tego pierwszego może być uznany jako: {{Code|cel}} {{=}} {{Code|1}}, który też nie może być podany w ramce dziecka. * {{Code|typ jednostki}} (parametr bazowy) i {{Code|typ jednostki i}} (parametr domyślny numerkowy) - i te z numerkiem: {{Code|typ jednostki 1}}, {{Code|typ jednostki 2}}, ..., tzn. gdy chcemy określić z jakim typem jednostki mamy do czynienia w zależności do jakiej przestrzeni nazw należy, a w danej, czy jest on np. programowy, czy tylko jest opisem, jak to bywa w szablonach {{Np|Template|link=tak}}, podobnie jest w przypadku {{Np|Module|link=tak}}, czy jak jest w innych przestrzeniach nazw, ** {{Code|dyskusja typu jednostki}} (parametr bazowy) i {{Code|dyskusja typu jednostki i}} (parametr domyślny numerkowy) - i te z numerkiem: {{Code|dyskusja typu jednostki 1}}, {{Code|dyskusja typu jednostki 2}}, ..., gdy chcemy określić wartością niepustą, że chodzi tutaj o typ jednostki. === Parametry bazowe i numerkowe === Parametry bazowe (bez numerka i {{Code|i}}, po spacji) są te z nazwami przestrzeni nazw, nazwami jednostek, typów jednostek i {{Code|dyskusja typu jednostki}}, jako nazwane bazowe, a te z numerkiem po spacji na końcu, jako numerkowe, a te z {{Code|i}} po spacji, jako ogólne numerkowe, to parametry ogólne dostępne dla wszystkich parametrów pudełkowych bazowych podanych powyżej, oprócz parametrów nazw jednostek, służą one, do tego, gdy jakaś zmienna numerkowa nie została podana, a jeżeli ona natomiast nie istnieje, to wtedy dla numerków brana jest ta wersja odpowiednia bazowa. === Ważność parametrów pudełkowych, parametry ramki rodzica, a dziecka === Parametry puddełkowe podawane w rodzicu w szablonie można dać w ramce dziecka, wtedy parametry dziecka mają pierwszeństwo. === Liczenie nazw przestrzeni nazw z parametrów przestrzennych i typów jednostek z parametrem dyskusja typu jednostek === Najpierw w funkcji nagłówku brane są parametry nazw przestrzeni nazw, a jeżeli ich nie ma, to parametry typu jednostki, a jeżeli nie ma, to generowane są typy jednostki na podstawie aktualnego modułu. === Notatka dla funkcji pudełkowych === Parametry pudełek nie powinno się podawać w dziecku w ramce, tylko w rodzicu w szablonie jako parametry, w którym ta ramka jest wywoływana, ale tutaj podano jedynie dla przykładu, jak najłatwiej sprawdzić działanie tych parametrów tej funkcji. == Opis rodzajów typów jednostek == Typy jednostek to odpowiednik przestrzeni nazw i nie tylko, bo mówi dodatkowo jakiego typu strona jest danej przestrzeni nazw, czy to jest główny artykół podręcznika, czy zwykły, itp., mówi jakie jest to korzeń strony danej przestrzeni, nie musi być do podręcznik, czy podręcznik dla dzieci, objawia, czy np. jest to brudnopis i jakiego typu, czy w brudnopisie {{lr2|Brudnopis}}, jaki to jest artykuł główny i zwykły. Dla stron szablonów i modułów, również im odpowiadające strony brudnopisu, tzn. {{ls2|Brudnopis}} i {{ld2|Brudnopis}}, w przestrzeniach danego użytkownika, jakie strony są szablonami, czy modułami, a jakie ich opisami. === Typy jednostek i odpowiadające im nazwy przedmiotowe przestrzeni nazw === Są to wartości zwracane przez funkcję ramki: {{Code|{{m|Pudełko|Typ jednostki}}}}, i jego podobnych, w języku {{lpg|Lua}} w {{lpr|Lua|Scribunto}}. One obrazują odpowiednie przestrzenie, które należy zasymulować lub w których się znajduje, jeżeli ta funkcja jest bez parametrów, nie licząc {{Parametr|numer jednostki}} lub ten parametr przyjmuje wartość zero, ale rodzic szablon, wtedy nie może przyjmować żadnych parametrów pudełkowych dla pozycji bazowej. Dla pozycji numerkowych ten parametr wskazuje jakiego typu przestrzenie nazw reprezentuje strona podana jako tego typu parametr, ale musi być podana ta zmienna numeru jednostki, np. z przykładowa wartością {{Parametr|numer jednostki|2}}. ==== Strony przedmiotowe ==== * Pzestrzeń główna - przestrzeń nazw {{Np|(main)|link=tak}}: ** {{Code|artykuł}} i {{Code|podręcznik}} - artykuł normalny podręcznika i jego strona główna, * Przestrzeń projektów dla dzieci - przestrzeń nazw {{Np|Wikijunior|link=tak}}: ** {{Code|artykuł dla dzieci}} i {{Code|podręcznik dla dzieci}} - artykuł normalny podręcznika dla dzieci i jego strona główna, w przestrzeni nazw {{Np|Wikijunior|link=tak}}, * Strony projektu - przestrzeń nazw {{Np|Project|link=tak}}: ** Podręczniki: *** {{Code|artykuł brudnopisu projektu}}, {{Code|podręcznik brudnopisu projektu}} - artykuł normalny brudnopisowy podręcznika i jego strona główna, w przestrzeni nazw {{lr2|Brudnopis}}, *** {{Code|jednostka brudnopisu projektu}} - jest to artykuł lub podręcznik w przestrzeni brudnopisowej {{lr2|Brudnopis}}, zamiast je nazywać jako {{Code|artykuł brudnopisu projektu}} lub {{Code|podręcznik brudnopisu projektu}}, ** Strony: *** {{Code|strona brudnopisu projektu}} - ogólnie nazwana strona brudnopisu projektu, zamiast je nazywać: {{Code|artykuł brudnopisu projektu}} lub {{Code|podręcznik brudnopisu projektu}} albo {{Code|jednostka brudnopisu projektu}}, ** {{Code|strona projektu}} - zwykła niebrudnopisowa strona projektu, * Strony szablonu - przestrezeń nazw {{Np|Template|link=tak}}: ** Strony niebrudnopisowe: *** {{Code|strona szablonu}} i {{Code|strona opisu szablonu}} - niebrudnopisowa strona szablonu i jego opisu, ** Strony brudnopisowe - nibyprzestrzeń nazw {{ls2|Brudnopis}}, *** {{Code|strona brudnopisu szablonu}} i {{Code|strona brudnopisu opisu szablonu}} - brudnopisowa strona szablonu i jego opisu, * Strony modułu - przestrzeń nazw {{Np|Module|link=tak}}: ** Strony niebrudnopisowe: *** {{Code|strona modułu}} i {{Code|strona opisu modułu}} - niebrudnopisowa strona modułu i jego opisu, ** Strony brudnopisowe - nibyprzestrzeń nazw {{ld2|brudnopis}}: *** {{Code|strona brudnopisu modułu}} i {{Code|strona brudnopisu opisu modułu}} - brudnopisow sstrona modułu i jego opisu, * Strony użytkownika - przestrzeń nazw {{Np|User|link=tak}}: ** Strony podręcznikowe: *** {{Code|artykuł użytkownika}} i {{Code|podręcznik użytkownika}} - artykuł normalny podręcznika i jego strona główna, *** {{Code|jednostka użytkownika}} - inaczej nazwana strony podręcznika, nawet główna, czyli {{Code|artykuł użytkownika}} i {{Code|podręcznik użytkownika}}, ** Inne strony: *** {{Code|strona główna użytkownika}} - strona główna użytkownika, *** {{Code|strona użytkownika}} - inaczej nazwana strona użytkownika, zamiast: {{Code|artykuł użytkownika}} i {{Code|podręcznik użytkownika}} oraz {{Code|strona główna użytkownika}}, * Inne typy jednostek: ** {{Code|strona pliku}} - strona w przestrzeni nazw pliku {{Np|File|link=tak}}, ** {{Code|strona kategorii}} - strona w przestrzeni nazw kategorii {{Np|Category|link=tak}}, ** {{Code|strona pomocy}} - strona pomocy w przestrzeni nazw pomocy {{Np|Help|link=tak}}, ** {{Code|strona komunikatu}} - strona komunikatów w przestrzeni nazw {{Np|MediaWiki|link=tak}}, ** {{Code|strona specjalna}} - strona specjalna w przestzreni nazw {{Np|Special|link=tak}}, ** {{Code|strona główna projektu}} - strona główna projektu {{lr2|Strona główna}} w przestrzeni nazw {{Np|Project|link=tak}}, ** {{Code|strona główna dla dzieci}} - strona główna dla dzieci {{lj2|Strona główna}} w przestrzeni nazw {{Np|Wikijunior|link=tak}}. ==== Strony dyskusji ==== Nazwy typu jednostek {{Code|typ jednostek}} są takie same jak dla przestrzeni przedmiotowej, tylko z tą różnicą, za po spacji po pierwszym wyrazie występuje wyraz {{Code|dyskusji}}. i tak tego typu typy jednostek dla różnych przestrzeni nazw dyskusji są tworzone. ; Przykłady * {{Code|artykuł}} → {{Code|artykuł dyskusji}}, * {{Code|artykuł dla dzieci}} → {{Code|artykuł dyskusji dla dzieci}}, * {{Code|strona użytkownika}} → {{Code|strona dyskusji użytkownika}}. ==== Strony niedopasowane ==== Jeżeli strona została niedopasowana do przestrzeni przedmiotowej, czy dyskusji, to funkcja {{Code|{{m|Pudełko|Typ jednostki}}}}, wtedy zwraca wartość {{Code|inne}}. === Tworzenie typów jednostek dyskusji i rodzina parametrów {{Code|dyskusja typu jednostki}} === Można poddać nazwę typu jednostki dla przestrzeni dyskusji, ale jest za to inny sposób, wtedy to samo skostrułować nalezy podać typ jednostki dla przestrzeni przedmiotowej i parametr dyskusji typu jednostki, np. dla pozycji bazowej {{Code|dyskusja typu jednostki}} z wartością {{Code|tak}}. Również z tą wartością może typ jednostki dla przestrzeni dyskusji, ale wtedy otrzymujemy tożssamość. Podobnie jest z tym dla parametrów typu jednostki i dyskusji typu jednostki dla pozycji numerkowej, tylko te parametry posiadają dodatkowy numerek na końcu po spacji lub podane w postaci ogólnej, jako litera {{Code|i}} na końcu tych zmiennych po spacji. === Parametry dodatkowe typów jednostek === ==== Wprowadzenie ==== Przedstawimy tu na przykładzie funkcji: {{Code|{{m|Pudełko|Typ jednostki}}}}, ale rozważania też dotyczą jego podobnych, tzn. wersji podstawowej, dwa i trzy oraz w wersji bezposredniej (typ jednostki jest liczony bez transformacji), przedmiotowej (typ jednostki jest zamieniany na przedmiotową) i dyskusji (typ jednostki jest zamieniany na dyskusji), niezależnie, czy to obrazuje przestrzeń nazw przedmiotową (o numerku parzystym), czy dyskusji (o numerku nieparzystym, o jeden zwyż w porównaniu z tą odpowiadającą przedmiotową). Dodatkowe parametry podajemy w ramce {{lpg|Lua}} w {{lpr|Lua|Scribunto}} w sposob, np: * {{Code|{{m|Pudełko|Typ jednostki|obsługiwane jednostki jako nieopisowe strony{{=}}tak}}}}. Lub z to samo, ale z parametrem {{Parametr|numer jednostki|2}} z przykładową wartością, wartość {{Code|0}}, wtedy tego parametru można nie podawać, oznacza przestrzeń bazową, a {{Code|1}}, {{Code|2}},..., natomiast numerkową, wtedy ten parametr jest konieczny, a te numerki oznaczają numer parametru typu jednostki lub dyskusji typu jednostki, więc: * {{Code|{{m|Pudełko|Typ jednostki|obsługiwane jednostki jako nieopisowe strony{{=}}tak|numer jednostki{{=}}2}}}}. Te parametry dodatkowe coś oznaczają. ==== Opis tych parametrów ==== W nagłówkach tytułów są to parametry podawane do ramki, w {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, w parametrach dziecka szablonu rodzica. Parametry te, które mają wartość pustą, można nie podawać, ale można, ale je można podać dla uwypuklenia problemu. Te parametry można łączyć ze sobą. Poniżej podano przykładowe wywołania z jednym tylko parametrem. Dokładniejszy opis tych funkcji ze strony programowej, jako kod w {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, jest na stronie {{Code|{{m|Pudełko/Pomocne}}}}. ===== {{Code|obsługiwane jednostki jako nieopisowe strony}} ===== Tę funkcje z tym parametrem wywołujemy umieszczając szablon z nim w jakieś przestrzeni nazw, a to wywołanie wygląda, w ktorych jeden z parametrów jest: : {{Code|{{m|Pudełko|Typ jednostki|obsługiwane jednostki jako nieopisowe strony{{=}}tak}}}}. Dla przestrzeni nazw po umieszczeniu szablonu z nim tam na stronie na wymienionych przestrzeniach nazw: * {{Np|(main)|link=tak}} - to wtedy funkcja zwraca wynik: {{Code|artykuł}}, * {{Np|Wikijunior|link=tak}} - to wtedy funkcja zwraca wynik: {{Code|artykuł dla dzieci}}, * {{Np|User|link=tak}} - to wtedy funkcja zwraca wynik: {{Code|strona użytkownika}}, * {{Np|Project|link=tak}} w nibyprzestrzeni nazw {{lr2|Brudnopis}} - to wtedy funkcja zwraca wynik: {{Code|strona brudnopisu projektu}}, * {{Np|Template|link=tak}} w nibyprzestrzeni nazw {{ls2|Brudnopis}} - to wtedy funkcja zwraca wynik: {{Code|strona brudnopisu szablonu}}, * {{Np|Module|link=tak}} w nibyprzestrzeni nazw {{ld2|Brudnopis}} - to wtedy funkcja zwraca wynik: {{Code|strona brudnopisu modułu}}. ===== {{Code|obsługiwane indywidua użytkownika jako normalne strony}} ===== Tę funkcje z tym parametrem wywołujemy umieszczając szablon z nim w jakieś przestrzeni nazw, a to wywołanie wygląda, w ktorych jeden z parametrów jest: : {{Code|{{m|Pudełko|Typ jednostki|obsługiwane indywidua użytkownika jako normalne strony{{=}}tak}}}}. * {{Np|User|link=tak}} - to wtedy funkcja zwraca wynik: {{Code|strona użytkownika}}. ===== {{Code|obsługiwane jednostki użytkownika}} ===== Tę funkcje z tym parametrem wywołujemy umieszczając szablon z nim w jakieś przestrzeni nazw, a to wywołanie wygląda, w ktorych jeden z parametrów jest: : {{Code|{{m|Pudełko|Typ jednostki|obsługiwane jednostki użytkownika{{=}}tak}}}}. * {{Np|User|link=tak}} to wtedy funkcja zwraca wynik: {{Code|artykuł użytkownika}} lub {{Code|podręcznik użytkownika}}, w przeciwnym wypadku: {{Code|jednostka użytkownika}}, w przypadku nieużycia tego parametru. ===== {{Code|obsługiwane brudnopisy jako normalne strony}} ===== Tę funkcje z tym parametrem wywołujemy umieszczając szablon z nim w jakieś przestrzeni nazw, a to wywołanie wygląda, w ktorych jeden z parametrów jest: : {{Code|{{m|Pudełko|Typ jednostki|obsługiwane brudnopisy jako normalne strony{{=}}tak}}}}. Dla przestrzeni nazw po umieszczeniu szablonu z nim tam na stronie na wymienionych przestrzeniach nazw: * {{Np|Project|link=tak}} - to wtedy otrzymamy: {{Code|strona projektu}}, * {{Np|Template|link=tak}} - to wtedy otrzymamy: {{Code|strona szablonu}} lub {{Code|strona opisu szablonu}}, * {{Np|Module|link=tak}} - to wtedy otrzymamy: {{Code|strona modułu}} lub {{Code|strona opisu modułu}}. ===== {{Code|obsługiwane jednostki brudnopisu projektu}} ===== Tę funkcje z tym parametrem wywołujemy umieszczając szablon z nim w jakieś przestrzeni nazw, a to wywołanie wygląda, w ktorych jeden z parametrów jest: : {{Code|{{m|Pudełko|Typ jednostki|obsługiwane jednostki brudnopisu projektu{{=}}tak}}}}. * {{Np|Project|link=tak}} - to wtedy otrzymamy: {{Code|artykuł brudnopisu projektu}} lub {{Code|podręcznik brudnopisu projektu}}, w przeciwnym wypadku: {{Code|jednostka brudnopisu projektu}}, w przypadku nieużycia tego parametru. ===== {{Code|obsługiwane strony jako niebrudnopisowe jednostki programowe}} ===== Tę funkcje z tym parametrem wywołujemy umieszczając szablon z nim w jakieś przestrzeni nazw, a to wywołanie wygląda, w ktorych jeden z parametrów jest: : {{Code|{{m|Pudełko|Typ jednostki|obsługiwane strony jako niebrudnopisowe jednostki programowe{{=}}tak}}}}. * {{Np|Template|link=tak}} - to wtedy otrzymamy wynik: {{Code|strona szablonu}}, * {{Np|Module|link=tak}} - to wtedy otrzymamy wynik: {{Code|strona modułu}}. ===== {{Code|obsługiwane opisy jako strony jednostek programowych}} ===== Tę funkcje z tym parametrem wywołujemy umieszczając szablon z nim w jakieś przestrzeni nazw, a to wywołanie wygląda, w ktorych jeden z parametrów jest: : {{Code|{{m|Pudełko|Typ jednostki|obsługiwane opisy jako strony jednostek programowych{{=}}tak}}}}. Dla przestrzeni nazw po umieszczeniu szablonu z nim tam na stronie na wymienionych przestrzeniach nazw: * {{Np|Template|link=tak}} - to wtedy otrzymamy: {{Code|strona brudnopisu szablonu}} lub {{Code|strona szablonu}}, * {{Np|Module|link=tak}} - to wtedy otrzymamy: {{Code|strona brudnopisu modułu}} lub {{Code|strona modułu}}. ===== {{Code|obsługiwane nieudokumentowane szablony jako szablony}} ===== Tę funkcje z tym parametrem wywołujemy umieszczając szablon z nim w jakieś przestrzeni nazw, a to wywołanie wygląda, w ktorych jeden z parametrów jest: : {{Code|{{m|Pudełko|Typ jednostki|obsługiwane nieudokumentowane szablony jako szablony{{=}}tak}}}}. Dla przestrzeni nazw po umieszczeniu szablonu z nim tam na stronie na wymienionych przestrzeniach nazw: * {{Np|Template|link=tak}} - to wtedy otrzymamy: {{Code|strona brudnopisu szablonu}} lub {{Code|strona szablonu}}. ==== Możliwe błędy wywołań {{Code|{{m|Pudełko|Typ jednostki}}}} i jego podobnych ==== Te błędy występują, w wywołaniach {{Code|{{m|Pudełko|Typ jednostki}}}} i jego podobnych, gdy typ jednostki podany do parametru rodzica ramki {{lpg|Lua}} w {{lpr|Lua|Scribunto}} jest o zawartości niepustej. ===== {{Code|(błąd typu jednostki)}} ===== Występuje, gdy typ jednostki nie chce się zgadzać, z wyróznionymi w funkcji, z nazwami przestrzeni nazw. Ten błąd występuje, gdy parametr {{Parametr|analiza}} jest o zawartości pustej lub nie podany. Wtedy typ jednostki nie jest liczony od nowa, aby sprawdzić z tą podaną. Ten błąd czasami występuje, gdy do wywołania tej funkcji dodamy parametr {{Parametr|analiza|tak}}, wtedy gdy nie podamy nazwy jednostki, i nie chcą się zgadzać parametry pudełkowe, w odróżnieniu od błędu {{Code|(błąd parametrów pudełkowych)}}. Wtedy typ jednostki jest liczony od nowa, aby sprawdzić z tą podaną. ===== {{Code|(błąd niezgodności)}} ===== Występuje, gdy uzyskana przestrzeń nazw z typu jednostki i parametrów przestrzennych, nie są ze sobą zgodne, gdy nazwa jednostki jest nie podana i parametr {{Parametr|analiza}} również lub jest o zawartości pustej. ===== {{Code|(błąd parametrów pudełkowych)}} ===== Występuje, gdy nazwa przestrzeni nazw i nazwa jednostki, dla parametrów bazowych i numerkowych, są podane, wtedy nie chcą się zgadzać parametry pudełkowe, tzn. parametry przestrzenne i jednostki oraz typu jednostki nie są ze sobą zgodne. Ten błąd występuje, gdy do wywołania tej funkcji dodamy parametr {{Parametr|analiza|tak}}. == Parametry pudełkowe == Tutaj przedstawione sa parametry funkcji pudełkowych we wszystkich wersjach, czy się rożnią parametry w ich różnych, jak są tworzone wartości, itp. Przedstawione tu wiadomości dotyczą funkcji pudełkowych nazw przestrzeni nazw, nazw jednostek, pełnych nazw stron i typów jednostek. === Parametry ramki i szablonu === Parametry funkcji to są parametry podawane bezpośrednio do funkcji. Są też parametry ramki tablicy transportu dzieckai jego rodzica. * Dla przykładu w opisach funkcji parametry będziemy podawać nie w rodzicu w szablonie, tylko w dziecku, jeśli chodzi o parametry różnych funkcji pudełkowych nazw przesstrzeni nazw, nazw jednostek, pełnych nazw jednostek i typów jednostek, ale ich się za to nie powinno podawać w tych ramkach, tylko w szablonach, w których wywoływane są te ramki pudełek {{Code|{{m|Pudełko}}}}, ale tak jest podawane w opisach tych funkcji w następnych tomach, że tak zrobiono by było najłatwiej sprawdzić działanie tego typu funkcji. ==== Parametry funkcji ==== ===== Funkcje nazw przestrzeni nazw i pełnych nazw jednostek, ich parametry ===== Funkcje nazw przestrzeni nazw i pełnych nazw jednostek mają następujące parametry: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|czy_uwzglednic_alternatywna_nazwe}} - czy ma uwzględniać nazwę przestrzeni nazw domyślną szablonu, dostępne wartości: {{Code|false}}, w której nazwa domyślna nie jest uwzględniana wtedy, oraz {{Code|nil}} i {{Code|true}}, które oznaczają to samo, w tym jeżeli ona jest uwzględniana, wtedy jest brany parametr pierwszy dziecka, który musi istnieć przy takiej wartości tego parametru, tzn. {{Code|{{m|Pudełko|<Funkcje nazw przestrzeni nazw i pełnych nazw jednostek>|Szablon}}}}, a ten element jest używany, gdy nazwa uzyskana nazwy przestrzeni nazw jest w takim przypadku błędna, a jeżeli wtedy nazwa domyślna jest błędna, czyli np.: {{Code|{{m|Pudełko|<Funkcje nazw przestrzeni nazw i pełnych nazw jednostek>|Moja przestrzeń}}}}, wtedy funkcja zwraca stan błędu {{Code|(błąd)}}, ** Przykład: {{Code|{{m|Pudełko|Nazwa przestrzeni nazw|Moja przestrzeń}}}}, * {{Code|i}} - numer zmiennej nazwy przestrzeni nazw. ===== Funkcje nazw jednostek i typów jednostek, ich parametry ===== Funkcje nazw jednostek mają następujące parametry: Parametry funkcji: * {{Code|frame}} - tablica ramki tablicy transportu, * {{Code|i}} - numer zmiennej nazwy przestrzeni nazw i nazwy jednostki. ==== Parametry rodzica ramki dziecka ==== Do tych parametrów reprezentującą nazwę przestrzeni nazw można podać typ jednostki i dyskusję typu jednostki z odpowiedniki wartościami. ===== Funkcje nazw przestrzeni nazw i typów jednostek, w wersji podstawowej ===== Funkcje te liczą nazwy przestrzeni nazw, wychodząc wyłącznie od zmiennych przestrzennych i typów jednostek, więc ona przyjmuje parametry: * Parametry przestrzenne bazowe i numerkowe, * Parametry typów jednostek, ** Parametry dyskusji typówj jednostek. ===== Funkcje nazw przestrzeni nazw i typów jednostek, w wersji drugiej ===== * W porównaniu z wersją podstawową potrzebuje on również parametry nazw jednostek bazowe i numerkowe. Dla funkcji dla parametrów bazowych i numerkowych bardzo ważne są wartości parametrów przestrzennych, a jezeli wzkazuje ona na przestrzeń główną lub ewentualnie na „Dyskusja” w przypadku funkcji przedmiotowych, to wtedy nazwa przestrzeni nazw jest liczona z parametrów nazw jednostek. ===== Funkcje nazw przestrzeni nazw i typów jednostek, w wersji trzeciej ===== * Wersja bazowa nazwy jednostek w porownaniu z wersją drugą jest niepotrzebna, a pozostały nazwy jednostek, te numerkowe już tak, a nazwy przestrzeni nazw są zawsze potrzebne, niezależnie jakie. * Dla parametrów przestrzennych wersja bazowa działa jak podstawowa, a numerkowe jak w wersji drugiej. ===== Funkcje nazw jednostek i ich parametry ===== ====== Funkcje nazw jednostek w wwersji podstawowej ====== * Funkcje nazw jednostek bezpośrednio ściągają policzony wynik ze zmiennej nazwy jednostek. ====== Funkcje nazw jednostek w wwersji drugiej ====== * Dla funkcji dla parametrów bazowych i numerkowych bardzo ważne są wartości parametrów przestrzennych, a jezeli wzkazuje ona na przestrzeń główną lub ewentualnie na „Dyskusja” w przypadku funkcji przedmiotowych, to znazwy jednostki jest odejmowana nazwa przestrzeni nazw, w przeciwnym wypadku nazwa jednostki jest powtarzana. ====== Funkcje nazw jednostek w wersji trzeciej ====== * Parametr nazw przestrzeni nazw dla parametrów bazowych jest niepotrzebny, a numerkowe już tak. * Dla parametrów nazw przestrzenni nazww, nazw jednostek i typów jednostek, a nawet dyskusji typów jednostek (podawane warz typami jednostek tylko), wersja bazowa działa jak podstawowa, a numerkowa jak w wersji drugiej. ===== Funkcje pełnych nazw jednostek ===== Te funkcje potrzebują parametrów zarówno przestrzennych jak i nazw jednostek dla parametrów bazowych i przestrzennych. ==== Parametry ramki dziecka w szablonie rodzica ==== Parametry ramki tablicy transportu dziecka: * Parametry dziecka są takie same jak rodzica dla funkcji pudełkowej bez parametrów, które są wyłącznie podawane w parametrach rodzica, * {{Code|numer jednostki}} - jak parametr {{Code|i}} parametru funkcji, a jeśli nie został ustawiony, to wtedy liczy się ta zmienna, jest to numer nazwy przestrzeni nazw, czy nazwy jednostki, a nawet typu jednostki, czy dyskusji typów jednostki. * Jest jeszcze pierwszy parametr, o nummerze {{Code|1}}, dla funkcji pudełkowych przestrzennych, pełnych nazw jednosteki typów jednostek, który jest domyślną nazwą przestrzeni nazw, jeżeli parametr ze zmiennej odpowiedniej przestrzennej ma nieprawidłową nazwę, a nawet taka przesstrzeń może nie istnieć. * Przykład: *# {{Code|{{m|#invoke:Pudełko|Nazwa porzestrzeni nazw|Template}}}}, *# czy inny przykład z numerem jednostki: {{Code|{{m|#invoke:Pudełko|Nazwa porzestrzeni nazw|Template|numer jednostki{{=}}2}}}}. * Też parametr dziecka pierwszy może mieć nieprawidłową nazwę, wtedy funkcja zrzuca stan błędu w postaci komunikatu {{Code|(błąd)}} w przypadku liczenia nazwy przestzreni nazw w pewnych funkcjach pudełkowych. ==== Funkcje pudełkowe bezpośrednie ==== * Funkcje licza bezpośrednio nazwę przestrzeni nazw bez transformacji na przedmiotową lub dyskusji, jest ona liczona z parametrów przestrzennych lub ewentualnie z nazwy jednostek, jeżeli odpowiednie parametry przestrzenne mają ściśle określone wartości. * Funkcje pełnych nazw jeddnostek wykorzystują funkcje, liczace nazwę przestrzeni nazw do liczenia nazwy przestrzeni nazw plus z nazwą jednostki tworzą pełny adres strony. ==== Funkcje pudełkowe przedmiotowe ==== Te parametry liczone przez te funkcje, w nich elementy przestrzenne są zamieniane na wartości przedmiotowe, tzn. nazwę przedmiotową nazwy przestrzenie nazw, czyli nie dyskusji, zamieniana jest na nią samą, czyli identyfikator przestrzeni się nie zmienia, a dyskusji, nie przedmiotową, przekształca się na przedmiotową jej odpowiadającą, czyli w tym przypadku identyfikator przestrzeni zmniejsza się o numer mniej. ==== Funkcje pudełkowe dyskusji ==== Te parametry liczone przez te funkcje, w nich elementy przestrzenne są zamieniane na wartości przedmiotowe, tzn. nazwę przedmiotową nazwy przestrzenie nazw, czyli nie dyskusji, zamieniana jest na dyskusji, czyli identyfikator przestrzeni się zmienia jeden wyżej, a dyskusji, nie przedmiotową, przekształca się na tą samą. == Jak tworzyć szablony pudełkowe na podstawie funkcji pudełkowych pudełek zdefiniowanych w: {{Code|{{m|Pudełko}}}} == Ten rozdział przedstawia ogólny sposób tworzenia szablonów pudełkowych z funkcjami pudełkowymi wywołań {{m|Pudełko}} z rożnymi funkcjami, niezależnie z jakimi wersjami. Przykładowy obraz wywołania szablony z parametrami pudełkowymi: <syntaxhighlight lang="mediawiki"> <!-- Szablon podany z parametrami pudełkowymi z parametrami bazowym i numerkowyminawet ogólnymi; --> {{Nazwa szablonu|nazwa przestrzeni nazw=Pomoc|nazwa przestrzeni nazw 2=Pomoc|nazwa przestrzeni nazw i=Moduł|nazwa jednostki=Wikibooks:Strona|nazwa jednostki 2=Pomoc:Strona}} </syntaxhighlight> W dziecku powiedzmy jest wywołanie, i szukamy nazwy przestrzeni nazw o numerze, np. dwa, która nie została podana, ale istnieje za to jej wersji ogólna {{Code|nazwa przestrzeni nazw i}} i domyślna {{Code|nazwa przestrzeni nazw}}, wtedy możemy powiedzieć w definicji tego szablonu: Dla parametrów bazowych, aby je uzyskać, przy różnych funkcjach pudełkowych, piszemy: <syntaxhighlight lang="mediawiki"> <!-- Wywołanie funkcji pudełkowej w szablonie {{Nazwa szablonu}}; --> {{#invoke:Pudełko|<nazwa funkcji pudełkowej w wersji bazowej lub numerkowej>}} <!-- Równowaznie możemy napisać: {{#invoke:Pudełko|<nazwa funkcji pudełkowej w wersji bazowej lub numerkowej>|numer jednostki=0}} --> </syntaxhighlight> Lub można napisać z parametrem numeru jednostki {{Code|numer jednostki}} z wartością większa niż zero,jako liczba całkowita dodatnia dla parametrów numerkowych: <syntaxhighlight lang="mediawiki"> <!-- Wywołanie funkcji pudełkowej w szablonie {{Nazwa szablonu}}; --> {{#invoke:Pudełko|<nazwa funkcji pudełkowej w wersji bazowej lub numerkowej>|numer jednostki=<numer jednostki parametru pudełkowych funkcji>}} </syntaxhighlight> Tą funkcję można też bezpośrednio wywołać na stronie z parametrami pudełkowymi plus parametr {{Parametr|numer jednostki|<jakiś numer>}}. Opis parametrów funkcji pudełkowych: * {{Code|<nazwa funkcji pudełkowej w wersji bazowej lub numerkowej>}} - jest to funkcja pudełkowa napisana w module {{Code|{{m|Pudełko}}}}, * {{Code|<numer jednostki parametru pudełkowych funkcji>}} - numer para,metru pudełkowego numerkowego lub numerkowych, jakieś funkcji w tym module. Funkcja drukuje wynik na podstawie typu funkcji pudełkowej przy pomocy numeru wersji lub w wersji, bedać w wersji bazowej, wtedy parametru {{Parametr|numer jednostki|0}} nie trzeba podawać, ale można z tą wartością. Przykładami ostatniego wywołania są: <syntaxhighlight lang="mediawiki"> <!-- Wywołanie funkcji pudełkowej w szablonie {{Nazwa szablonu}}; --> <!-- Pierwszy przykład --> {{#invoke:Pudełko|Nazwa przestrzeni nazw}} <!-- liczenie nazwy przestrzeni nazw dla jednostki bazowej --> {{#invoke:Pudełko|Nazwa jednostki}} <!-- liczenie nazwy jednostki dla jednostki bazowej --> <!-- Drugi przykład --> {{#invoke:Pudełko|Nazwa przestrzeni nazw|numer jednostki=2}} <!-- Liczenie nazwy przestrzeni nazw dla jednostki o numerze dwa --> {{#invoke:Pudełko|Nazwa jednostki|numer jednostki=2}} <!-- Liczenie nazwy jednostki dla jednostki o numerze dwa --> </syntaxhighlight> == Spis treści == === Dokumentacja modułu {{Code|{{ld2|Pudełko}}}} === * {{lr|Moduły/Pudełko/Tom I|Tom I}} - opis funkcji, nazw przestrzeni nazw i nazwy jednostek, normalnych, przedmiotowych i dyskusji, * {{lr|Moduły/Pudełko/Tom II|Tom II}} - opis funkcji, pełnych nazw jednostek, * {{lr|Moduły/Pudełko/Tom III|Tom III}} - opis funkcji typu jednostek, * {{lr|Moduły/Pudełko/Tom IV|Tom IV}} - opis funkcji błędów i cech (stworzonych na podstawie tego błędów) pudełka, normalnych, przedmiotowych i dyskusji. * {{lr|Moduły/Pudełko/Tom V|Tom V}} - Także dokumentacji kodów i kluczy wiki, nazw stron projektu i dla dzieci, funkcje badania jakie to wiki oraz kody wiki tego projektu, itp. Opisuje funkcje, czy do szablonów pudełek podano parametry numerowane, nienazwane i nazwane. === Inne podmoduły === * {{sr|Pomocne|p=Pudełko|Pudełko - Pomocne}} - funkcje, z których korzystają funkcje zdefiniowane w wywołaniach modułowych {{m|Pudełko}}, * {{sr|Potrzebne|p=Pudełko|Pudełko - Potrzebne}} - funnkcje potrzebne do budowy wywołań ogólnego pudełka {{m|Pudełko|Ogólne pudełko}}, * {{sr|ParametryCechy|p=Pudełko|Pudełko - Parametry Cechy}} - funkcje zapytań potrzebne do implementacji szablonu {{s|Szablonowy opis pudełka}}. {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> kch80gbpiy8yqd27a6dfneaskpls0hf 4 63495 541360 541167 2026-04-30T09:08:54Z Persino 2851 541360 wikitext text/x-wiki <noinclude>{{ProstaStronaStart | nagłówek = {{Podrozdział|{{ld2|Pudełko}}|Dokumentacja modułów {{lpg|Lua}} w {{lpr|Lua|Scribunto}}.}}{{Autonawigacja|Pomoc:Spis treści}} | stopka strony = {{StopkaSpisTreści}}{{Podrozdział|Koniec}} }}</noinclude> {{Spis treści}} == {{Code|p.CzyNiepoprawnaNazwa(nazwa_jednostki)}} == Funkcja sprawdzajaca, czy jest poprawnie podana nazwa jednostki, czy ma poprawną nazwę. Znakami tymi, z których nie powinna składać się nazwa jest {{Code|<nowiki>{}<>|[]#\n</nowiki>}} i dodatkowo znak {{Code|&#127;}} (kod {{Code|{{Nowiki|&#127;}}}}). Też nie może składać się z trzech znaków tyldy, tzn. {{Code|<nowiki>~~~</nowiki>}}. Również w swojej budowie nie może składać się ze kodów {{Strong|HTML}} literowych o wzorze {{Code|{{Nowiki|&(%a+);}}}}. Natomiast może składać się z {{Code|{{Nowiki|&#(%d+);}}}} i {{Code|{{Nowiki|&#x(%x+);}}}}, ale w pierw te kody muszą być zamienione na normalne znaki. Skrótowa definicja funkcji: <syntaxhighlight lang="lua"> function p.CzyNiepoprawnaNazwa(nazwa_jednostki)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> -- Moduł: "Moduł:Html/dane", służy do ładowania znaku o kodzie HTML "&#127;"; local html_dane_modul=mw.loadData("Module:Html/dane"); return mw.ustring.match(nazwa_jednostki,"[{}<>|%[%]#\n"..html_dane_modul.znak_127.."]+") or mw.ustring.match(nazwa_jednostki,"~~~") or mw.ustring.match(nazwa_jednostki,"&(%a+);"); </syntaxhighlight> Parametry: * {{Code|nazwa_jednostki}} - nazwa jednostki do sprawdzenia. Przykłady: <syntaxhighlight lang="lua"> local pudelko_modul=require("Module:Pudełko"); -- Podana przykładowa niepoprawna nazwa jedostki local nazwa_jednostki="Nazwa pliku [[Nazwa linku w pliku]]"; -- Funkcja zwróci wartość: local czy_poprawna_nazwa=true; local czy_poprawna_nazwa=pudelko_modul.CzyNiepoprawnaNazwa(nazwa_jednostki); </syntaxhighlight> == Funkcje nazw przestrzeni nazw == === {{Code|p["Nazwa przestrzeni nazw"](frame,...)}} === Funkcja liczy bezpośrednio nazwę przestrzeni nazw z parametrów przestrzennych, czy z typów jednostek,a nawet z dyskusja typu jednostek podawane wraz z tymi ostatnimi. Przestrzeń nazw z parametrów nazw przestrzennych może odpowiadać wartości przestrzeni głównej, to wtedy odpowiednia przestrzeń nazw z parametru nazwy jednostki się nie liczy w tej funkcji, aby się liczyła należy użyć funkcji {{Code|{{sr|#p["Nazwa przestrzeni nazw 2"](frame,...)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa przestrzeni nazw"]=function(frame,czy_uwzglednic_alternatywna_nazwe,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> -- Jest liczony numer parametru nazwy przestrzeni nazw, domyslnie chodzi tu o numer bazowy parametrów przestrzennych; local numer_jednostki=i or frame.args["numer jednostki"]; local liczba_numer_jednostki=((numer_jednostki)and(tonumber(numer_jednostki))or 0); local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); -- Liczy nazwę przestrzeni nazw na podstawie podanych parametrów; return pudelko_pomocne_modul.Nazwa_przestrzeni_nazw(frame,0, czy_uwzglednic_alternatywna_nazwe,liczba_numer_jednostki); </syntaxhighlight> Funkcja wykorzystuje {{Code|{{sr|#p.Nazwa_przestrzeni_nazw(frame,...)|p=Pudełko/Pomocne}}}} do wyznaczania ogólnego nazwy przestrzeni nazw dla pozycji bazowej i numerkowej, tzn. dla pozycji: jeden, dwa, trzy,..., itd, i ich ogólnej, tzn. według funkcji: {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, dla pozycji zerowej. Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw|Szablon|nazwa przestrzeni nazw i{{=}}Moja przestrzeń|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw|Szablon|nazwa przestrzeni nazw i=Moja przestrzeń|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw|nazwa przestrzeni nazw 2{{=}}Pomoc|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw|nazwa przestrzeni nazw 2=Pomoc|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw|nazwa przestrzeni nazw 2{{=}}Pomoc|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw|nazwa przestrzeni nazw i=Pomoc|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw|nazwa przestrzeni nazw{{=}}Pomoc|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw|nazwa przestrzeni nazw=Pomoc|numer jednostki=2}}}} === {{Code|p["Nazwa przedmiotowej przestrzeni nazw"](frame,...)}} === Funkcja liczy bezpośrednio nazwę przedmiotowej przestrzeni nazw z parametrów przestrzennych, czy z typów jednostek,a nawet z dyskusja typu jednostek podawane wraz z tymi ostatnimi. Przestrzeń nazw z parametrów nazw przestrzennych może odpowiadać wartości przestrzeni głównej, to wtedy odpowiednia przestrzeń nazw z parametru nazwy jednostki się nie liczy w tej funkcji, aby się liczyła należy użyć funkcji {{Code|{{sr|#p["Nazwa przedmiotowej przestrzeni nazw 2"](frame,...)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa przedmiotowej przestrzeni nazw"]=function(frame,czy_uwzglednic_alternatywna_nazwe,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> -- Jest liczony numer parametru nazwy przestrzeni nazw, domyslnie chodzi tu o numer bazowy parametrów przestrzennych; local numer_jednostki=i or frame.args["numer jednostki"]; local liczba_numer_jednostki=((numer_jednostki)and(tonumber(numer_jednostki))or 0); local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); -- Liczy nazwę przestrzeni nazw przedmiotową na podstawie podanych parametrów; return pudelko_pomocne_modul.Nazwa_przestrzeni_nazw(frame,1, czy_uwzglednic_alternatywna_nazwe,liczba_numer_jednostki); </syntaxhighlight> Funkcja wykorzystuje {{Code|{{sr|#p.Nazwa_przestrzeni_nazw(frame,...)|p=Pudełko/Pomocne}}}} do wyznaczania ogólnego nazwy przestrzeni nazw dla pozycji bazowej i numerkowej, tzn. dla pozycji: jeden, dwa, trzy,..., itd, i ich ogólnej, tzn. według funkcji: {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, dla pozycji zerowej. Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw|Dyskusja szablonu|nazwa przestrzeni nazw i{{=}}Moja przestrzeń|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw|Dyskusja szablonu|nazwa przestrzeni nazw i=Moja przestrzeń|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw|nazwa przestrzeni nazw 2{{=}}Dyskuja pomocy|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw|nazwa przestrzeni nazw 2=Dyskuja pomocy|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw|nazwa przestrzeni nazw 2{{=}}Dyskuja pomocy|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw|nazwa przestrzeni nazw i=Dyskuja pomocy|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw|nazwa przestrzeni nazw{{=}}Dyskuja pomocy|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw|nazwa przestrzeni nazw=Dyskuja pomocy|numer jednostki=2}}}} === {{Code|p["Nazwa przestrzeni nazw dyskusji"](frame,...)}} === Funkcja liczy bezpośrednio nazwę dyskusji przestrzeni nazw z parametrów przestrzennych, czy z typów jednostek,a nawet z dyskusja typu jednostek podawane wraz z tymi ostatnimi. Przestrzeń nazw z parametrów nazw przestrzennych może odpowiadać wartości przestrzeni głównej, to wtedy odpowiednia przestrzeń nazw z parametru nazwy jednostki się nie liczy w tej funkcji, aby się liczyła należy użyć funkcji {{Code|{{sr|#p["Nazwa przestrzeni nazw dyskusji 2"](frame,...)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa przestrzeni nazw dyskusji"]=function(frame,czy_uwzglednic_alternatywna_nazwe,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> -- Jest liczony numer parametru nazwy przestrzeni nazw, domyslnie chodzi tu o numer bazowy parametrów przestrzennych; local numer_jednostki=i or frame.args["numer jednostki"]; local liczba_numer_jednostki=((numer_jednostki)and(tonumber(numer_jednostki))or 0); local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); -- Liczy nazwę przestrzeni nazw dyskusji na podstawie podanych parametrów; return pudelko_pomocne_modul.Nazwa_przestrzeni_nazw(frame,2, czy_uwzglednic_alternatywna_nazwe,liczba_numer_jednostki); </syntaxhighlight> Funkcja wykorzystuje {{Code|{{sr|#p.Nazwa_przestrzeni_nazw(frame,...)|p=Pudełko/Pomocne}}}} do wyznaczania ogólnego nazwy przestrzeni nazw dla pozycji bazowej i numerkowej, tzn. dla pozycji: jeden, dwa, trzy,..., itd, i ich ogólnej, tzn. według funkcji: {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, dla pozycji zerowej. Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw dyskusji|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw dyskusji|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw dyskusji|Szablon|nazwa przestrzeni nazw i{{=}}Moja przestrzeń|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw dyskusji|Szablon|nazwa przestrzeni nazw i=Moja przestrzeń|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw dyskusji|nazwa przestrzeni nazw 2{{=}}Pomoc|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw dyskusji|nazwa przestrzeni nazw 2=Pomoc|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw dyskusji|nazwa przestrzeni nazw 2{{=}}Pomoc|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw dyskusji|nazwa przestrzeni nazw i=Pomoc|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw dyskusji|nazwa przestrzeni nazw{{=}}Pomoc|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw dyskusji|nazwa przestrzeni nazw=Pomoc|numer jednostki=2}}}} == Funkcje nazw przestrzeni nazw drugiej wersji == === {{Code|p["Nazwa przestrzeni nazw 2"](frame,...)}} === Funkcja liczy nazwę przestrzeni nazw z parametrów przestrzennych, ewentualnie nazw jednostek, czy z typów jednostek,a nawet z dyskusja typu jednostek podawane wraz z tymi ostatnimi. Przestrzeń nazw z parametrów nazw przestrzennych może odpowiadać wartości przestrzeni głównej, to wtedy odpowiednia przestrzeń nazw z parametru nazwy jednostki się liczy w tej funkcji, wtedy jest liczona nazwa przestrzeni nazw z tego parametru. Gdy parametry przestrzenne lub typ jednostki w drugim podejściu nie wskazują na przestrzeń główną, to wtedy działanie tej funkcji jest podobne do {{Code|{{sr|#p["Nazwa przestrzeni nazw"](frame,...)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa przestrzeni nazw 2"]=function(frame,czy_uwzglednic_alternatywna_nazwe,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); -- Liczy nazwę przestrzeni nazw, jeżeli z parametrów przestrzennych przestrzeń wskazuje na główną, to wtedy jest liczona przestrzeń nazw z nazwy jednostki; return pudelko_pomocne_modul.Nazwa_przestrzeni_nazw_2(frame,czy_uwzglednic_alternatywna_nazwe,i) </syntaxhighlight> Funkcja wykorzystuje {{Code|{{sr|#p.Nazwa_przestrzeni_nazw_2(frame,...)|p=Pudełko/Pomocne}}}} do wyznaczania ogólnego nazwy przestrzeni nazw dla pozycji bazowej i numerkowej, tzn. dla pozycji: jeden, dwa, trzy,..., itd, i ich ogólnej, tzn. według funkcji: {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, dla pozycji zerowej. Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw 2|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw 2|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw 2|Szablon|nazwa przestrzeni nazw i{{=}}Moja przestrzeń|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw 2|Szablon|nazwa przestrzeni nazw i=Moja przestrzeń|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw 2|nazwa przestrzeni nazw 2{{=}}|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw 2|nazwa przestrzeni nazw 2=|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw 2|nazwa przestrzeni nazw i{{=}}|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw 2|nazwa przestrzeni nazw i=|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw 2|Szablon|nazwa przestrzeni nazw{{=}}|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw 2|Szablon|nazwa przestrzeni nazw=|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} === {{Code|p["Nazwa przedmiotowej przestrzeni nazw 2"](frame,...)}} === Funkcja liczy nazwę przedmiotowej przestrzeni nazw z parametrów przestrzennych, ewentualnie nazw jednostek, czy z typów jednostek,a nawet z dyskusja typu jednostek podawane wraz z tymi ostatnimi. Przestrzeń nazw z parametrów nazw przestrzennych po przekształceniu na przedmiotową może odpowiadać wartości przestrzeni głównej (wtedy to odpowiada przestrzeni głównej, czy „Dyskusja”), to wtedy odpowiednia przestrzeń nazw z parametru nazwy jednostki się liczy w tej funkcji, wtedy jest liczona nazwa przestrzeni nazw z tego parametru. Gdy parametry przestrzenne lub typ jednostki w drugim podejściu nie wskazują na przestrzeń główną, to wtedy działanie tej funkcji jest podobne do {{Code|{{sr|#p["Nazwa przedmiotowej przestrzeni nazw"](frame,...)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa przedmiotowej przestrzeni nazw 2"]=function(frame,czy_uwzglednic_alternatywna_nazwe,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); return pudelko_pomocne_modul.Nazwa_przestrzeni_nazw_przedmiotowa_dyskusji_2(frame,czy_uwzglednic_alternatywna_nazwe,i,"przedmiotowa"); </syntaxhighlight> Funkcja wykorzystuje {{Code|{{sr|#p.Nazwa_przestrzeni_nazw_przedmiotowa_dyskusji_2(frame,...)|p=Pudełko/Pomocne}}}} do wyznaczania ogólnego nazwy przestrzeni nazw dla pozycji bazowej i numerkowej, tzn. dla pozycji: jeden, dwa, trzy,..., itd, i ich ogólnej, tzn. według funkcji: {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, dla pozycji zerowej. Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw 2|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw 2|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw 2|Dyskusja szablonu|nazwa przestrzeni nazw i{{=}}Moja przestrzeń|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw 2|Dyskusja szablonu|nazwa przestrzeni nazw i=Moja przestrzeń|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw 2|nazwa przestrzeni nazw 2{{=}}Dyskusja|nazwa jednostki 2{{=}}Dyskuja pomocy:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw 2|nazwa przestrzeni nazw 2=Dyskusja|nazwa jednostki 2=Dyskuja pomocy:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw 2|nazwa przestrzeni nazw i{{=}}Dyskusja|nazwa jednostki 2{{=}}Dyskuja pomocy:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw 2|nazwa przestrzeni nazw i=Dyskusja|nazwa jednostki 2=Dyskuja pomocy:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw 2|Dyskusja szablonu|nazwa przestrzeni nazw{{=}}Dyskusja|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw 2|Dyskusja szablonu|nazwa przestrzeni nazw=Dyskusja|nazwa jednostki 2=Dyskuja pomocy:Strona|numer jednostki=2}}}} === {{Code|p["Nazwa przestrzeni nazw dyskusji 2"](frame,...)}} === Funkcja liczy nazwę dyskusji przestrzeni nazw z parametrów przestrzennych, ewentualnie nazw jednostek, czy z typów jednostek,a nawet z dyskusja typu jednostek podawane wraz z tymi ostatnimi. Przestrzeń nazw z parametrów nazw przestrzennych po przekształceniu może odpowiadać wartości przestrzeni głównej, to wtedy odpowiednia przestrzeń nazw z parametru nazwy jednostki się liczy w tej funkcji, wtedy jest liczona nazwa przestrzeni nazw dyskusji z tego parametru. Gdy parametry przestrzenne lub typ jednostki w drugim podejściu nie wskazują na przestrzeń główną, to wtedy działanie tej funkcji jest podobne do {{Code|{{sr|#p["Nazwa dyskusji przestrzeni nazw"](frame,...)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa przestrzeni nazw dyskusji 2"]=function(frame,czy_uwzglednic_alternatywna_nazwe,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); return pudelko_pomocne_modul.Nazwa_przestrzeni_nazw_przedmiotowa_dyskusji_2(frame,czy_uwzglednic_alternatywna_nazwe,i,"dyskusja"); </syntaxhighlight> Funkcja wykorzystuje {{Code|{{sr|#p.Nazwa_przestrzeni_nazw_przedmiotowa_dyskusji_2(frame,...)|p=Pudełko/Pomocne}}}} do wyznaczania ogólnego nazwy przestrzeni nazw dla pozycji bazowej i numerkowej, tzn. dla pozycji: jeden, dwa, trzy,..., itd, i ich ogólnej, tzn. według funkcji: {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, dla pozycji zerowej. Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw dyskusji 2|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw dyskusji 2|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw dyskusji 2|Szablon|nazwa przestrzeni nazw i{{=}}Moja przestrzeń|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw dyskusji 2|Szablon|nazwa przestrzeni nazw i=Moja przestrzeń|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw dyskusji 2|nazwa przestrzeni nazw 2{{=}}|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw dyskusji 2|nazwa przestrzeni nazw 2=|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw dyskusji 2|nazwa przestrzeni nazw i{{=}}|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw dyskusji 2|nazwa przestrzeni nazw i=|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw dyskusji 2|Szablon|nazwa przestrzeni nazw{{=}}|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw dyskusji 2|Szablon|nazwa przestrzeni nazw=|nazwa jednostki 2=Dyskuja pomocy:Strona|numer jednostki=2}}}} == Funkcje nazw przestrzeni nazw trzeciej wersji == === {{Code|p["Nazwa przestrzeni nazw 3"](frame,...)}} === Funkcja liczy nazwę przestrzeni nazw z parametrów przestrzennych, ewentualnie nazw jednostek, czy z typów jednostek,a nawet z dyskusja typu jednostek podawane wraz z tymi ostatnimi. Przestrzeń nazw z parametrów nazw przestrzennych bazowych (bez numerka) może odpowiadać wartości przestrzeni głównej, to wtedy odpowiednia przestrzeń nazw z parametru nazwy jednostki się nie liczy w tej funkcji, aby się liczyła należy użyć funkcji {{Code|{{sr|#p["Nazwa przestrzeni nazw 2"](frame,...)|p=Pudełko/Tom I}}}}. W tym przypadku funkcja działa jak {{Code|{{sr|#p["Nazwa przestrzeni nazw"](frame,...)|p=Pudełko/Tom I}}}}. Przestrzeń nazw z parametrów nazw przestrzennych numerkowych może odpowiadać wartości przestrzeni głównej, to wtedy odpowiednia przestrzeń nazw z parametru nazwy jednostki się liczy w tej funkcji, wtedy jest liczona nazwa przestrzeni nazw z tego parametru. Gdy parametry przestrzenne lub typ jednostki w drugim podejściu nie wskazują na przestrzeń główną, to wtedy działanie tej funkcji jest podobne do {{Code|{{sr|#p["Nazwa przestrzeni nazw 2"](frame,...)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa przestrzeni nazw 3"]=function(frame,czy_uwzglednic_alternatywna_nazwe,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> -- Jest liczony numer parametru nazwy przestrzeni nazw, domyslnie chodzi tu o numer bazowy parametrów przestrzennych; local numer_jednostki=i or frame.args["numer jednostki"]; local liczba_numeru_jednostki=((numer_jednostki)and(tonumber(numer_jednostki)) or 0); local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); -- Liczy nazwę przestrzeni nazw dyskusji na podstawie podanych parametrów; return pudelko_pomocne_modul.Uzyskanie_nazw_jednostki(frame,0,liczba_numeru_jednostki,nil,2); </syntaxhighlight> Funkcja wykorzystuje {{Code|{{sr|#p.Uzyskanie_nazw_jednostki(frame,...)|p=Pudełko/Pomocne}}}} do wyznaczania ogólnego nazwy przestrzeni nazw dla pozycji bazowej i numerkowej, tzn. dla pozycji: jeden, dwa, trzy,..., itd, i ich ogólnej, tzn. według funkcji: {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, dla pozycji zerowej. Ta funkcja uruchamia dla parametrów bazowych funkcje: {{Code|{{sr|#p["Nazwa przestrzeni nazw"](frame,...)|p=Pudełko/Tom I}}}}, a dla numerkowych: {{Code|{{sr|#p["Nazwa przestrzeni nazw 2"](frame,...)|p=Pudełko/Tom I}}}}. Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw 3|Szablon|nazwa przestrzeni nazw{{=}}Moja przestrzeń|nazwa jednostki{{=}}Pomoc:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw 3|Szablon|nazwa przestrzeni nazw=Moja przestrzeń|nazwa jednostki=Pomoc:Strona}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw 3|Szablon|nazwa przestrzeni nazw 2{{=}}Moja przestrzeń|nazwa jednostki 2{{=}}Pomoc:Strona}|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw 3|Szablon|nazwa przestrzeni nazw 2=Moja przestrzeń|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw 3|nazwa przestrzeni nazw{{=}}|nazwa jednostki{{=}}Pomoc:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw 3|nazwa przestrzeni nazw=|nazwa jednostki=Pomoc:Strona}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw 3|nazwa przestrzeni nazw 2{{=}}|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw 3|nazwa przestrzeni nazw 2=|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} === {{Code|p["Nazwa przedmiotowej przestrzeni nazw 3"](frame,...)}} === Funkcja liczy nazwę przedmiotowej przestrzeni nazw z parametrów przestrzennych, ewentualnie nazw jednostek, czy z typów jednostek,a nawet z dyskusja typu jednostek podawane wraz z tymi ostatnimi. Przestrzeń nazw z parametrów nazw przestrzennych bazowych (bez numerka) może odpowiadać wartości przedmiotowej, po transformacji, przestrzeni głównej (to odpowiada przestrzeni głównej, czy „Dyskusja”), to wtedy odpowiednia przestrzeń nazw z parametru nazwy jednostki się nie liczy w tej funkcji, aby się liczyła należy użyć funkcji {{Code|{{sr|#p["Nazwa przedmiotowej przestrzeni nazw 2"](frame,...)|p=Pudełko/Tom I}}}}. W tym przypadku funkcja działa jak {{Code|{{sr|#p["Nazwa przedmiotowej przestrzeni nazw"](frame,...)|p=Pudełko/Tom I}}}}. Przestrzeń nazw z parametrów nazw przestrzennych numerkowych może odpowiadać wartości, po przekształceniu, przedmiotowej przestrzeni głównej (okresla to przestrzeń nazw główną lub „Dyskusja”), to wtedy odpowiednia przestrzeń nazw z parametru nazwy jednostki się liczy w tej funkcji, wtedy jest liczona nazwa przestrzeni nazw z tego parametru. Gdy parametry przestrzenne lub typ jednostki w drugim podejściu nie wskazują na przestrzeń główną, to wtedy działanie tej funkcji jest podobne do {{Code|{{sr|#p["Nazwa przedmiotowej przestrzeni nazw 2"](frame,...)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa przedmiotowej przestrzeni nazw 3"]=function(frame,czy_uwzglednic_alternatywna_nazwe,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> -- Jest liczony numer parametru nazwy przestrzeni nazw, domyslnie chodzi tu o numer bazowy parametrów przestrzennych; local numer_jednostki=i or frame.args["numer jednostki"]; local liczba_numeru_jednostki=((numer_jednostki)and(tonumber(numer_jednostki)) or 0); local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); -- Liczy nazwę przestrzeni nazw przedmiotową na podstawie podanych parametrów; return pudelko_pomocne_modul.Uzyskanie_nazw_jednostki(frame,1,liczba_numeru_jednostki,nil,1); </syntaxhighlight> Funkcja wykorzystuje {{Code|{{sr|#p.Uzyskanie_nazw_jednostki(frame,...)|p=Pudełko/Pomocne}}}} do wyznaczania ogólnego nazwy przestrzeni nazw dla pozycji bazowej i numerkowej, tzn. dla pozycji: jeden, dwa, trzy,..., itd, i ich ogólnej, tzn. według funkcji: {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, dla pozycji zerowej. Ta funkcja uruchamia dla parametrów bazowych funkcje: {{Code|{{sr|#p["Nazwa przedmiotowej przestrzeni nazw"](frame,...)|p=Pudełko/Tom I}}}}, a dla numerkowych: {{Code|{{sr|#p["Nazwa przedmiotowej przestrzeni nazw 2"](frame,...)|p=Pudełko/Tom I}}}}. Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw 3|Dyskusja szablonu|nazwa przestrzeni nazw{{=}}Moja przestrzeń|nazwa jednostki{{=}}Dyskuja pomocy:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw 3|Dyskusja szablonu|nazwa przestrzeni nazw=Moja przestrzeń||nazwa jednostki=Dyskuja pomocy:Strona}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw 3|Dyskusja szablonu|nazwa przestrzeni nazw 2{{=}}Moja przestrzeń|nazwa jednostki 2{{=}}Dyskuja pomocy:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw 3|Dyskusja szablonu|nazwa przestrzeni nazw 2=Moja przestrzeń||nazwa jednostki 2=Dyskuja pomocy:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw 3|nazwa przestrzeni nazw{{=}}|nazwa jednostki{{=}}Dyskuja pomocy:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw 3|nazwa przestrzeni nazw=|nazwa jednostki=Dyskuja pomocy:Strona}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw 3|nazwa przestrzeni nazw 2{{=}}|nazwa jednostki 2{{=}}Dyskuja pomocy:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw 3|nazwa przestrzeni nazw 2=|nazwa jednostki 2=Dyskuja pomocy:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw 3|nazwa przestrzeni nazw{{=}}Dyskusja|nazwa jednostki{{=}}Dyskuja pomocy:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw 3|nazwa przestrzeni nazw=Dyskusja|nazwa jednostki=Dyskuja pomocy:Strona}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowej przestrzeni nazw 3|nazwa przestrzeni nazw 2{{=}}Dyskusja|nazwa jednostki 2{{=}}Dyskuja pomocy:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowej przestrzeni nazw 3|nazwa przestrzeni nazw 2=Dyskusja|nazwa jednostki 2=Dyskuja pomocy:Strona|numer jednostki=2}}}} === {{Code|p["Nazwa przestrzeni nazw dyskusji 3"](frame,...)}} === Funkcja liczy nazwę dyskusji przestrzeni nazw z parametrów przestrzennych, ewentualnie nazw jednostek, czy z typów jednostek,a nawet z dyskusja typu jednostek podawane wraz z tymi ostatnimi. Przestrzeń nazw z parametrów nazw przestrzennych bazowych (bez numerka) może odpowiadać wartości przestrzeni głównej, to wtedy odpowiednia przestrzeń nazw z parametru nazwy jednostki się nie liczy w tej funkcji, aby się liczyła należy użyć funkcji {{Code|{{sr|#p["Nazwa przestrzeni nazw dyskusji 2"](frame,...)|p=Pudełko/Tom I}}}}. W tym przypadku funkcja działa jak {{Code|{{sr|#p["Nazwa przestrzeni nazw dyskusji"](frame,...)|p=Pudełko/Tom I}}}}. Przestrzeń nazw z parametrów nazw przestrzennych numerkowych może odpowiadać wartości przestrzeni głównej, to wtedy odpowiednia przestrzeń nazw z parametru nazwy jednostki się liczy w tej funkcji, wtedy jest liczona nazwa przestrzeni nazw z tego parametru. Gdy parametry przestrzenne lub typ jednostki w drugim podejściu nie wskazują na przestrzeń główną, to wtedy działanie tej funkcji jest podobne do {{Code|{{sr|#p["Nazwa przestrzeni nazw dyskusji 2"](frame,...)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa przestrzeni nazw dyskusji 3"]=function(frame,czy_uwzglednic_alternatywna_nazwe,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> -- Jest liczony numer parametru nazwy przestrzeni nazw, domyslnie chodzi tu o numer bazowy parametrów przestrzennych; local numer_jednostki=i or frame.args["numer jednostki"]; local liczba_numeru_jednostki=((numer_jednostki)and(tonumber(numer_jednostki)) or 0); local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); -- Liczy nazwę przestrzeni nazw dyskusji na podstawie podanych parametrów; return pudelko_pomocne_modul.Uzyskanie_nazw_jednostki(frame,2,liczba_numeru_jednostki,nil,1); </syntaxhighlight> Funkcja wykorzystuje {{Code|{{sr|#p.Uzyskanie_nazw_jednostki(frame,...)|p=Pudełko/Pomocne}}}} do wyznaczania ogólnego nazwy przestrzeni nazw dla pozycji bazowej i numerkowej, tzn. dla pozycji: jeden, dwa, trzy,..., itd, i ich ogólnej, tzn. według funkcji: {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, dla pozycji zerowej. Ta funkcja uruchamia dla parametrów bazowych funkcje: {{Code|{{sr|#p["Nazwa przestrzeni nazw dyskusji"](frame,...)|p=Pudełko/Tom I}}}}, a dla numerkowych: {{Code|{{sr|#p["Nazwa przestrzeni nazw dyskusji 2"](frame,...)|p=Pudełko/Tom I}}}}. Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw dyskusji 3|Szablon|nazwa przestrzeni nazw{{=}}Moja przestrzeń|nazwa jednostki{{=}}Pomoc:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw dyskusji 3|Szablon|nazwa przestrzeni nazw=Moja przestrzeń|nazwa jednostki=Pomoc:Strona}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw dyskusji 3|Szablon|nazwa przestrzeni nazw 2{{=}}Moja przestrzeń|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw dyskusji 3|Szablon|nazwa przestrzeni nazw 2=Moja przestrzeń|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw dyskusji 3|nazwa przestrzeni nazw{{=}}|nazwa jednostki{{=}}Pomoc:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw dyskusji 3|nazwa przestrzeni nazw=|nazwa jednostki=Pomoc:Strona}}}} * {{Code|{{m|Pudełko|Nazwa przestrzeni nazw dyskusji 3|nazwa przestrzeni nazw 2{{=}}|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przestrzeni nazw dyskusji 3|nazwa przestrzeni nazw 2=|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} == Funkcje nazw jednostki == === {{Code|p["Nazwa jednostki"](frame,i)}} === Funckja bezpośrednio przepisuje nazwę jednostki z parametrów nazwy jednostki. Jeżeli chcemy, aby funkcja liczyła prawdziwą nazwę jednostki, nawet gdy nazwa przestrzeni jest o wartości pustej (wskazuje na przestrzeń główną), wtedy należy użyć funkcji {{Code|{{sr|#p["Nazwa jednostki 2"](frame,i)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa jednostki"]=function(frame,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); -- Liczenie nazwy jednostki, nawet gdyby ona była z przestrzenią nazw; return pudelko_pomocne_modul.Nazwa_jednostki(frame,i); </syntaxhighlight> Funkcja wykorzystuje {{Code|{{sr|#p.Nazwa_jednostki(frame,i)|p=Pudełko/Pomocne}}}} do wyznaczania ogólnego nazwy jednostki dla pozycji bazowej i numerkowej, tzn. dla pozycji: jeden, dwa, trzy,..., itd, i ich ogólnej, tzn. według funkcji: {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, dla pozycji zerowej. Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa jednostki|nazwa przestrzeni nazw{{=}}Szablon|nazwa jednostki{{=}}Pomoc:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa jednostki|nazwa przestrzeni nazw=Szablon|nazwa jednostki=Pomoc:Strona}}}} * {{Code|{{m|Pudełko|Nazwa jednostki|nazwa przestrzeni nazw 2{{=}}Szablon|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa jednostki|nazwa przestrzeni nazw 2=Szablon|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa jednostki|nazwa przestrzeni nazw{{=}}|nazwa jednostki{{=}}Pomoc:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa jednostki|nazwa przestrzeni nazw=|nazwa jednostki=Pomoc:Strona}}}} * {{Code|{{m|Pudełko|Nazwa jednostki|nazwa przestrzeni nazw 2{{=}}|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa jednostki|nazwa przestrzeni nazw 2=|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} == Funkcje nazw jednostki drugiej wersji == === {{Code|p["Nazwa jednostki 2"](frame,i)}} === Funkcja liczy nazwę jednostki na podstawie parametrów przestrzennych i nazw jednostki, jeżeli nazwa przestrzeni nazw ma odpowiednią nazwę, to jest liczona nazwa strony z nazwy jednostek. Jeżeli chcemy, aby funkcja liczyła podaną nazwę jednostki, niezależnie nawet gdy nazwa przestrzeni jest o wartości pustej (wskazuje na przestrzeń główną), czy nie, wtedy należy użyć funkcji {{Code|{{sr|#p["Nazwa jednostki"](frame,i)|p=Pudełko/Tom I}}}}. Jeżeli z parametrów przestrzennych wynika przestrzeń główna, to wtedy jest wyznaczana nazwa strony z parametrów jednostek odpowiadających, w pozostałych przypadkach ona działa, jak {{Code|{{sr|#p["Nazwa jednostki"](frame,i)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa jednostki 2"]=function(frame,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); -- Liczenie nazwy jednostki, bez nazwy przestrzeni w nazwie strony, jeżeli parametry przestrzenne wskazują na przestrzeń główną; return pudelko_pomocne_modul.Jaka_nazwa_jednostki(frame,i,nil); </syntaxhighlight> Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa jednostki 2|nazwa przestrzeni nazw{{=}}Szablon|nazwa jednostki{{=}}Pomoc:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa jednostki 2|nazwa przestrzeni nazw=Szablon|nazwa jednostki=Pomoc:Strona}}}} * {{Code|{{m|Pudełko|Nazwa jednostki 2|nazwa przestrzeni nazw 2{{=}}Szablon|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa jednostki 2|nazwa przestrzeni nazw 2=Szablon|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa jednostki 2|nazwa przestrzeni nazw{{=}}|nazwa jednostki{{=}}Pomoc:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa jednostki 2|nazwa przestrzeni nazw=|nazwa jednostki=Pomoc:Strona}}}} * {{Code|{{m|Pudełko|Nazwa jednostki 2|nazwa przestrzeni nazw 2{{=}}|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa jednostki 2|nazwa przestrzeni nazw 2=|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} === {{Code|p["Nazwa przedmiotowa jednostki 2"](frame,i)}} === Funkcja liczy przedmiotową nazwę jednostki na podstawie parametrów przestrzennych i nazw jednostki, jeżeli nazwa przestrzeni nazw ma odpowiednią nazwę, to jest liczona nazwa strony z nazwy jednostek. Co to znaczy przedmiotowa nazwa jednostki, tzn. gdy parametry przestrzenne wskazują na przestrzeń głównej i „Dyskusja”, wtedy ona zostanie zamieniona na przestrzeń główną, i wtedy jest liczona nazwa strony bez przestrzeni nazw z nazwy jednostki. W pozostałych przypadkach funkcja działa jak {{Code|{{sr|#p["Nazwa jednostki 2"](frame,i)|p=Pudełko/Tom I}}}}. Parametry podaje się w parametrach rodzica wywołania tej funkcji {{Code|{{m|Pudełko|Nazwa przedmiotowa jednostki 2}}}} (ale ich nie trzeba podawać w dziecku, ale można) i w parametrach dziecka, jeśli chodzi o zmienną {{Code|numer jednostki}}, czyli np.: {{Code|{{m|Pudełko|Nazwa przedmiotowa jednostki 2|numer jednostki{{=}}<jakaś liczba całkowita naturalna>}}}}. Jeżeli chcemy, aby funkcja liczyła podaną nazwę jednostki, niezależnie nawet gdy przedmiotowa, po zamianie, nazwa przestrzeni jest o wartości pustej (wskazuje na przestrzeń główną, czy „Dyskusja”), czy nie, wtedy należy użyć funkcji {{Code|{{sr|#p["Nazwa jednostki"](frame,i)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa przedmiotowa jednostki 2"]=function(frame,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); -- Liczenie nazwy jednostki, bez nazwy przestrzeni w nazwie strony, jeżeli parametry przestrzenne wskazują na przestrzeń nazw główną i "Dyskusji"; return pudelko_pomocne_modul.Jaka_nazwa_jednostki(frame,i,"przedmiotowa"); </syntaxhighlight> Funkcja wykorzystuje {{Code|{{sr|#p.Jaka_nazwa_jednostki(frame,...)|p=Pudełko/Pomocne}}}} do wyznaczania ogólnego nazwy jednostki dla pozycji bazowej i numerkowej, tzn. dla pozycji: jeden, dwa, trzy,..., itd, i ich ogólnej, tzn. według funkcji: {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, dla pozycji zerowej. Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa przedmiotowa jednostki 2|nazwa przestrzeni nazw{{=}}Dyskuja pomocy|nazwa jednostki{{=}}Dyskuja pomocy:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowa jednostki 2|nazwa przestrzeni nazw=Dyskuja pomocy|nazwa jednostki=Dyskuja pomocy:Strona}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowa jednostki 2|nazwa przestrzeni nazw 2{{=}}Dyskuja pomocy|nazwa jednostki 2{{=}}Dyskuja pomocy:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowa jednostki 2|nazwa przestrzeni nazw 2=Dyskuja pomocy|nazwa jednostki 2=Dyskuja pomocy:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowa jednostki 2|nazwa przestrzeni nazw{{=}}Dyskusja|nazwa jednostki{{=}}Dyskuja pomocy:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowa jednostki 2|nazwa przestrzeni nazw=Dyskusja|nazwa jednostki=Dyskuja pomocy:Strona}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowa jednostki 2|nazwa przestrzeni nazw 2{{=}}Dyskusja|nazwa jednostki 2{{=}}Dyskuja pomocy:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowa jednostki 2|nazwa przestrzeni nazw 2=Dyskusja|nazwa jednostki 2=Dyskuja pomocy:Strona|numer jednostki=2}}}} === {{Code|p["Nazwa dyskusji jednostki 2"](frame,i)}} === Funkcja liczy dyskusji nazwę jednostki na podstawie parametrów przestrzennych i nazw jednostki, jeżeli nazwa przestrzeni nazw ma odpowiednią nazwę, to jest liczona nazwa strony z nazwy jednostek. Co to znaczy nazwa jednostki dyskusji, tzn. gdy parametry przestrzenne wskazują na przestrzeń główną, to wtedy ona nie jest zamieniana na „Dyskusja”, i wtedy jest liczona nazwa strony bez przestrzeni nazw z nazwy jednostki. W pozostałych przypadkach funkcja działa dla jak {{Code|{{sr|#p["Nazwa jednostki 2"](frame,i)|p=Pudełko/Tom I}}}}. Parametry podaje się w parametrach rodzica wywołania tej funkcji {{Code|{{m|Pudełko|Nazwa dyskusji jednostki 2}}}} (ale ich nie trzeba podawać w dziecku, ale można) i w parametrach dziecka, jeśli chodzi o zmienną {{Code|numer jednostki}}, czyli np.: {{Code|{{m|Pudełko|Nazwa dyskusji jednostki 2|numer jednostki{{=}}<jakaś liczba całkowita naturalna>}}}}. Jeżeli chcemy, aby funkcja liczyła podaną nazwę jednostki, niezależnie nawet gdy przedmiotowa nazwa przestrzeni jest o wartości pustej (wskazuje na przestrzeń główną), czy nie, wtedy należy użyć funkcji {{Code|{{sr|#p["Nazwa jednostki"](frame,i)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa dyskusji jednostki 2"]=function(frame,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); -- Liczenie nazwy jednostki, bez nazwy przestrzeni w nazwie strony, jeżeli parametry przestrzenne wskazują na przestrzeń nazw główną; return pudelko_pomocne_modul.Jaka_nazwa_jednostki(frame,i,"dyskusja"); </syntaxhighlight> Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa dyskusji jednostki 2|nazwa przestrzeni nazw{{=}}Szablon|nazwa jednostki{{=}}Pomoc:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa dyskusji jednostki 2|nazwa przestrzeni nazw=Szablon|nazwa jednostki=Pomoc:Strona}}}} * {{Code|{{m|Pudełko|Nazwa dyskusji jednostki 2|nazwa przestrzeni nazw 2{{=}}Szablon|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa dyskusji jednostki 2|nazwa przestrzeni nazw 2=Szablon|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa dyskusji jednostki 2|nazwa przestrzeni nazw{{=}}|nazwa jednostki{{=}}Pomoc:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa dyskusji jednostki 2|nazwa przestrzeni nazw=|nazwa jednostki=Pomoc:Strona}}}} * {{Code|{{m|Pudełko|Nazwa dyskusji jednostki 2|nazwa przestrzeni nazw 2{{=}}|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa dyskusji jednostki 2|nazwa przestrzeni nazw 2=|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} == Funkcje nazw jednostki trzeciej wersji == === {{Code|p["Nazwa jednostki 3"](frame,i)}} === Funkcja liczy nazwę jednostki na podstawie parametrów przestrzennych i nazw jednostki, jeżeli nazwa przestrzeni nazw ma odpowiednią nazwę, to jest liczona nazwa strony z nazwy jednostek. Ta funkcja tak działa, dla parametrów przestrzennych oraz jednostek, bazowych, jak {{Code|{{sr|#p["Nazwa jednostki"](frame,i)|p=Pudełko/Tom I}}}}, i numerkowych, jak {{Code|{{sr|#p["Nazwa jednostki 2"](frame,i)|p=Pudełko/Tom I}}}}. Jeżeli chcemy, aby funkcja liczyła podaną nazwę jednostki, niezależnie nawet gdy nazwa przestrzeni jest o wartości pustej (wskazuje na przestrzeń główną), czy nie, niezależnie, czy jest bazowa, czy numerkową, wtedy należy użyć funkcji {{Code|{{sr|#p["Nazwa jednostki"](frame,i)|p=Pudełko/Tom I}}}} i {{Code|{{sr|#p["Nazwa jednostki 2"](frame,i)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa jednostki 3"]=function(frame,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> -- Jest liczony numer parametru nazwy przestrzeni nazw, domyslnie chodzi tu o numer bazowy parametrów przestrzennych i jednostek; local numer_jednostki=i or frame.args["numer jednostki"]; local liczba_numeru_jednostki=((numer_jednostki)and(tonumber(numer_jednostki)) or 0); local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); -- Liczy nazwę przestrzeni nazw na podstawie podanych parametrów; return pudelko_pomocne_modul.Uzyskanie_nazw_jednostki(frame,0,nil,liczba_numeru_jednostki,nil,2); </syntaxhighlight> Funkcja wykorzystuje {{Code|{{sr|#p.Uzyskanie_nazw_jednostki(frame,...)|p=Pudełko/Pomocne}}}} , tzn. dla pozycji: jeden, dwa, trzy,..., itd, i ich ogólnej, tzn. według funkcji: {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, dla pozycji zerowej. Ta funkcja uruchamia dla parametrów bazowych funkcje: {{Code|{{sr|#p["Nazwa jednostki"](frame,i)|p=Pudełko/Tom I}}}}, a dla numerkowych: {{Code|{{sr|#p["Nazwa jednostki 2"](frame,i)|p=Pudełko/Tom I}}}}. Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa jednostki 3|nazwa przestrzeni nazw{{=}}Szablon|nazwa jednostki{{=}}Pomoc:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa jednostki 3|nazwa przestrzeni nazw=Szablon|nazwa jednostki=Pomoc:Strona}}}} * {{Code|{{m|Pudełko|Nazwa jednostki 3|nazwa przestrzeni nazw 2{{=}}Szablon|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa jednostki 3|nazwa przestrzeni nazw 2=Szablon|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa jednostki 3|nazwa przestrzeni nazw{{=}}|nazwa jednostki{{=}}Pomoc:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa jednostki 3|nazwa przestrzeni nazw=|nazwa jednostki=Pomoc:Strona}}}} * {{Code|{{m|Pudełko|Nazwa jednostki 3|nazwa przestrzeni nazw 2{{=}}|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa jednostki 3|nazwa przestrzeni nazw 2=|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} === {{Code|p["Nazwa przedmiotowa jednostki 3"](frame,i)}} === Funkcja liczy przedmiotową nazwę jednostki na podstawie parametrów przestrzennych i nazw jednostki, jeżeli nazwa przestrzeni nazw ma odpowiednią nazwę, to jest liczona nazwa strony z nazwy jednostek. Ta funkcja tak działa, dla parametrów przestrzennych oraz jednostek, bazowych, jak {{Code|{{sr|#p["Nazwa jednostki"](frame,i)|p=Pudełko/Tom I}}}}, i numerkowych, jak {{Code|{{sr|#p["Nazwa przedmiotowa jednostki 2"](frame,i)|p=Pudełko/Tom I}}}}. Jeżeli chcemy, aby funkcja liczyła podaną nazwę jednostki, niezależnie nawet gdy przedmiotowa nazwa przestrzeni jest o wartości pustej (wskazuje na przestrzeń główną, czy „Dyskusja”), czy nie, niezależnie, czy jest bazowa, czy numerkową, wtedy należy użyć funkcji {{Code|{{sr|#p["Nazwa jednostki"](frame,i)|p=Pudełko/Tom I}}}} i {{Code|{{sr|#p["Nazwa przedmiotowa jednostki 2"](frame,i)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa przedmiotowa jednostki 3"]=function(frame,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> -- Jest liczony numer parametru nazwy przestrzeni nazw, domyslnie chodzi tu o numer bazowy parametrów przestrzennych i jednostek; local numer_jednostki=i or frame.args["numer jednostki"]; local liczba_numeru_jednostki=((numer_jednostki)and(tonumber(numer_jednostki)) or 0); local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); -- Liczy nazwę przestrzeni nazw na podstawie podanych parametrów; return pudelko_pomocne_modul.Uzyskanie_nazw_jednostki(frame,1,nil,liczba_numeru_jednostki,nil,2); </syntaxhighlight> Funkcja wykorzystuje {{Code|{{sr|#p.Uzyskanie_nazw_jednostki(frame,...)|p=Pudełko/Pomocne}}}} do wyznaczania ogólnego nazwy jednostki dla pozycji bazowej i numerkowej, tzn. dla pozycji: jeden, dwa, trzy,..., itd, i ich ogólnej, tzn. według funkcji: {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, dla pozycji zerowej. Ta funkcja uruchamia dla parametrów bazowych funkcje: {{Code|{{sr|#p["Nazwa jednostki"](frame,i)|p=Pudełko/Tom I}}}}, a dla numerkowych: {{Code|{{sr|#p["Nazwa przedmiotowa jednostki 2"](frame,i)|p=Pudełko/Tom I}}}}. Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa przedmiotowa jednostki 3|nazwa przestrzeni nazw{{=}}Szablon|nazwa jednostki{{=}}Dyskuja pomocy:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowa jednostki 3|nazwa przestrzeni nazw=Szablon|nazwa jednostki=Dyskuja pomocy:Strona}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowa jednostki 3|nazwa przestrzeni nazw 2{{=}}Szablon|nazwa jednostki 2{{=}}Dyskuja pomocy:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowa jednostki 3|nazwa przestrzeni nazw 2=Szablon|nazwa jednostki 2=Dyskuja pomocy:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowa jednostki 3|nazwa przestrzeni nazw{{=}}|nazwa jednostki{{=}}Dyskuja pomocy:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowa jednostki 3|nazwa przestrzeni nazw=|nazwa jednostki=Dyskuja pomocy:Strona}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowa jednostki 3|nazwa przestrzeni nazw 2{{=}}|nazwa jednostki 2{{=}}Dyskuja pomocy:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowa jednostki 3|nazwa przestrzeni nazw 2=|nazwa jednostki 2=Dyskuja pomocy:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowa jednostki 3|nazwa przestrzeni nazw{{=}}Dyskusja|nazwa jednostki{{=}}Dyskuja pomocy:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowa jednostki 3|nazwa przestrzeni nazw=Dyskusja|nazwa jednostki=Dyskuja pomocy:Strona}}}} * {{Code|{{m|Pudełko|Nazwa przedmiotowa jednostki 3|nazwa przestrzeni nazw 2{{=}}Dyskusja|nazwa jednostki 2{{=}}Dyskuja pomocy:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa przedmiotowa jednostki 3|nazwa przestrzeni nazw 2=Dyskusja|nazwa jednostki 2=Dyskuja pomocy:Strona|numer jednostki=2}}}} === {{Code|p["Nazwa dyskusji jednostki 3"](frame,i)}} === Funkcja liczy dyskusji nazwę jednostki na podstawie parametrów przestrzennych i nazw jednostki, jeżeli nazwa przestrzeni nazw ma odpowiednią nazwę, to jest liczona nazwa strony z nazwy jednostek. Ta funkcja tak działa, dla parametrów przestrzennych oraz jednostek, bazowych, jak {{Code|{{sr|#p["Nazwa jednostki"](frame,i)|p=Pudełko/Tom I}}}}, i numerkowych, jak {{Code|{{sr|#p["Nazwa dyskusji jednostki 2"](frame,i)|p=Pudełko/Tom I}}}}. Jeżeli chcemy, aby funkcja liczyła podaną nazwę jednostki, niezależnie nawet gdy nazwa przestrzeni jest o wartości pustej (wskazuje na przestrzeń główną), czy nie, niezależnie, czy jest bazowa, czy numerkową, wtedy należy użyć funkcji {{Code|{{sr|#p["Nazwa jednostki"](frame,i)|p=Pudełko/Tom I}}}} i {{Code|{{sr|#p["Nazwa dyskusji jednostki 2"](frame,i)|p=Pudełko/Tom I}}}}. Definicja skrótowa funkcji: <syntaxhighlight lang="lua"> p["Nazwa dyskusji jednostki 3"]=function(frame,i)...end; </syntaxhighlight> Wtedy ciało funkcji tej, czyli jego definicja w środku, jest: <syntaxhighlight lang="lua"> -- Jest liczony numer parametru nazwy przestrzeni nazw, domyslnie chodzi tu o numer bazowy parametrów przestrzennych i jednostek; local numer_jednostki=i or frame.args["numer jednostki"]; local liczba_numeru_jednostki=((numer_jednostki)and(tonumber(numer_jednostki)) or 0); local pudelko_pomocne_modul=require("Module:Pudełko/Pomocne"); -- Liczy nazwę przestrzeni nazw na podstawie podanych parametrów; return pudelko_pomocne_modul.Uzyskanie_nazw_jednostki(frame,2,nil,liczba_numeru_jednostki,nil,2); </syntaxhighlight> Funkcja wykorzystuje {{Code|{{sr|#p.Uzyskanie_nazw_jednostki(frame,...)|p=Pudełko/Pomocne}}}} do wyznaczania ogólnego nazwy jednostki dla pozycji bazowej i numerkowej, tzn. dla pozycji: jeden, dwa, trzy,..., itd, i ich ogólnej, tzn. według funkcji: {{lpg|Lua}} w {{lpr|Lua|Scribunto}}, dla pozycji zerowej. Ta funkcja uruchamia dla parametrów bazowych funkcje: {{Code|{{sr|#p["Nazwa jednostki"](frame,i)|p=Pudełko/Tom I}}}}, a dla numerkowych: {{Code|{{sr|#p["Nazwa dyskusji jednostki 2"](frame,i)|p=Pudełko/Tom I}}}}. Przykłady w wikikodzie: * {{Code|{{m|Pudełko|Nazwa dyskusji jednostki 3|nazwa przestrzeni nazw{{=}}Szablon|nazwa jednostki{{=}}Pomoc:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa dyskusji jednostki 3|nazwa przestrzeni nazw=Szablon|nazwa jednostki=Pomoc:Strona}}}} * {{Code|{{m|Pudełko|Nazwa dyskusji jednostki 3|nazwa przestrzeni nazw 2{{=}}Szablon|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa dyskusji jednostki 3|nazwa przestrzeni nazw 2=Szablon|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa dyskusji jednostki 3|nazwa przestrzeni nazw{{=}}|nazwa jednostki{{=}}Pomoc:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa dyskusji jednostki 3|nazwa przestrzeni nazw=|nazwa jednostki=Pomoc:Strona}}}} * {{Code|{{m|Pudełko|Nazwa dyskusji jednostki 3|nazwa przestrzeni nazw 2{{=}}|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa dyskusji jednostki 3|nazwa przestrzeni nazw 2=|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} * {{Code|{{m|Pudełko|Nazwa dyskusji jednostki 3|nazwa przestrzeni nazw{{=}}Dyskusja|nazwa jednostki{{=}}Pomoc:Strona}}}} → {{Tt|{{#invoke:Pudełko|Nazwa dyskusji jednostki 3|nazwa przestrzeni nazw=Dyskusja|nazwa jednostki=Pomoc:Strona}}}} * {{Code|{{m|Pudełko|Nazwa dyskusji jednostki 3|nazwa przestrzeni nazw 2{{=}}Dyskusja|nazwa jednostki 2{{=}}Pomoc:Strona|numer jednostki{{=}}2}}}} → {{Tt|{{#invoke:Pudełko|Nazwa dyskusji jednostki 3|nazwa przestrzeni nazw 2=Dyskusja|nazwa jednostki 2=Pomoc:Strona|numer jednostki=2}}}} {{BrClear}} <noinclude><!-- -->{{ProstaStronaKoniec}}<!-- -->{{Kategoria|Opisy funkcji, w Lua w Scribunto, w modułach}}<!-- --></noinclude> o1p4hvumh8o6gfkjuyipyiybr64yxxi